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
48 static const void *cur_data
;
49 static data_size_t cur_size
;
51 static const char *get_status_name( unsigned int status
);
53 /* utility functions */
55 static inline void remove_data( data_size_t size
)
57 cur_data
= (const char *)cur_data
+ size
;
61 static void dump_uints( const int *ptr
, int len
)
66 fprintf( stderr
, "%08x", *ptr
++ );
67 if (--len
) fputc( ',', stderr
);
72 static void dump_handles( const char *prefix
, const obj_handle_t
*data
, data_size_t size
)
74 data_size_t len
= size
/ sizeof(*data
);
76 fprintf( stderr
,"%s{", prefix
);
79 fprintf( stderr
, "%04x", *data
++ );
80 if (--len
) fputc( ',', stderr
);
85 static void dump_timeout( const char *prefix
, const timeout_t
*time
)
87 fprintf( stderr
, "%s%s", prefix
, get_timeout_str(*time
) );
90 static void dump_uint64( const char *prefix
, const unsigned __int64
*val
)
92 if ((unsigned int)*val
!= *val
)
93 fprintf( stderr
, "%s%x%08x", prefix
, (unsigned int)(*val
>> 32), (unsigned int)*val
);
95 fprintf( stderr
, "%s%08x", prefix
, (unsigned int)*val
);
98 static void dump_rectangle( const char *prefix
, const rectangle_t
*rect
)
100 fprintf( stderr
, "%s{%d,%d;%d,%d}", prefix
,
101 rect
->left
, rect
->top
, rect
->right
, rect
->bottom
);
104 static void dump_char_info( const char *prefix
, const char_info_t
*info
)
106 fprintf( stderr
, "%s{'", prefix
);
107 dump_strW( &info
->ch
, 1, stderr
, "\'\'" );
108 fprintf( stderr
, "',%04x}", info
->attr
);
111 static void dump_ioctl_code( const char *prefix
, const ioctl_code_t
*code
)
115 #define CASE(c) case c: fprintf( stderr, "%s%s", prefix, #c ); break
116 CASE(FSCTL_DISMOUNT_VOLUME
);
117 CASE(FSCTL_PIPE_DISCONNECT
);
118 CASE(FSCTL_PIPE_LISTEN
);
119 CASE(FSCTL_PIPE_WAIT
);
120 CASE(WS_SIO_ADDRESS_LIST_CHANGE
);
121 default: fprintf( stderr
, "%s%08x", prefix
, *code
); break;
126 static void dump_cpu_type( const char *prefix
, const cpu_type_t
*code
)
130 #define CASE(c) case CPU_##c: fprintf( stderr, "%s%s", prefix, #c ); break
136 default: fprintf( stderr
, "%s%u", prefix
, *code
); break;
141 static void dump_apc_call( const char *prefix
, const apc_call_t
*call
)
143 fprintf( stderr
, "%s{", prefix
);
147 fprintf( stderr
, "APC_NONE" );
150 dump_uint64( "APC_USER,func=", &call
->user
.func
);
151 dump_uint64( ",args={", &call
->user
.args
[0] );
152 dump_uint64( ",", &call
->user
.args
[1] );
153 dump_uint64( ",", &call
->user
.args
[2] );
154 fputc( '}', stderr
);
157 dump_timeout( "APC_TIMER,time=", &call
->timer
.time
);
158 dump_uint64( ",arg=", &call
->timer
.arg
);
161 dump_uint64( "APC_ASYNC_IO,func=", &call
->async_io
.func
);
162 dump_uint64( ",user=", &call
->async_io
.user
);
163 dump_uint64( ",sb=", &call
->async_io
.sb
);
164 fprintf( stderr
, ",status=%s", get_status_name(call
->async_io
.status
) );
166 case APC_VIRTUAL_ALLOC
:
167 dump_uint64( "APC_VIRTUAL_ALLOC,addr==", &call
->virtual_alloc
.addr
);
168 dump_uint64( ",size=", &call
->virtual_alloc
.size
);
169 fprintf( stderr
, ",zero_bits=%u,op_type=%x,prot=%x",
170 call
->virtual_alloc
.zero_bits
, call
->virtual_alloc
.op_type
,
171 call
->virtual_alloc
.prot
);
173 case APC_VIRTUAL_FREE
:
174 dump_uint64( "APC_VIRTUAL_FREE,addr=", &call
->virtual_free
.addr
);
175 dump_uint64( ",size=", &call
->virtual_free
.size
);
176 fprintf( stderr
, ",op_type=%x", call
->virtual_free
.op_type
);
178 case APC_VIRTUAL_QUERY
:
179 dump_uint64( "APC_VIRTUAL_QUERY,addr=", &call
->virtual_query
.addr
);
181 case APC_VIRTUAL_PROTECT
:
182 dump_uint64( "APC_VIRTUAL_PROTECT,addr=", &call
->virtual_protect
.addr
);
183 dump_uint64( ",size=", &call
->virtual_protect
.size
);
184 fprintf( stderr
, ",prot=%x", call
->virtual_protect
.prot
);
186 case APC_VIRTUAL_FLUSH
:
187 dump_uint64( "APC_VIRTUAL_FLUSH,addr=", &call
->virtual_flush
.addr
);
188 dump_uint64( ",size=", &call
->virtual_flush
.size
);
190 case APC_VIRTUAL_LOCK
:
191 dump_uint64( "APC_VIRTUAL_LOCK,addr=", &call
->virtual_lock
.addr
);
192 dump_uint64( ",size=", &call
->virtual_lock
.size
);
194 case APC_VIRTUAL_UNLOCK
:
195 dump_uint64( "APC_VIRTUAL_UNLOCK,addr=", &call
->virtual_unlock
.addr
);
196 dump_uint64( ",size=", &call
->virtual_unlock
.size
);
199 fprintf( stderr
, "APC_MAP_VIEW,handle=%04x", call
->map_view
.handle
);
200 dump_uint64( ",addr=", &call
->map_view
.addr
);
201 dump_uint64( ",size=", &call
->map_view
.size
);
202 dump_uint64( ",offset=", &call
->map_view
.offset
);
203 fprintf( stderr
, ",zero_bits=%u,alloc_type=%x,prot=%x",
204 call
->map_view
.zero_bits
, call
->map_view
.alloc_type
, call
->map_view
.prot
);
207 dump_uint64( "APC_UNMAP_VIEW,addr=", &call
->unmap_view
.addr
);
209 case APC_CREATE_THREAD
:
210 dump_uint64( "APC_CREATE_THREAD,func=", &call
->create_thread
.func
);
211 dump_uint64( ",arg=", &call
->create_thread
.arg
);
212 dump_uint64( ",reserve=", &call
->create_thread
.reserve
);
213 dump_uint64( ",commit=", &call
->create_thread
.commit
);
214 fprintf( stderr
, ",suspend=%u", call
->create_thread
.suspend
);
217 fprintf( stderr
, "type=%u", call
->type
);
220 fputc( '}', stderr
);
223 static void dump_apc_result( const char *prefix
, const apc_result_t
*result
)
225 fprintf( stderr
, "%s{", prefix
);
231 fprintf( stderr
, "APC_ASYNC_IO,status=%s,total=%u",
232 get_status_name( result
->async_io
.status
), result
->async_io
.total
);
233 dump_uint64( ",apc=", &result
->async_io
.apc
);
234 dump_uint64( ",arg=", &result
->async_io
.arg
);
236 case APC_VIRTUAL_ALLOC
:
237 fprintf( stderr
, "APC_VIRTUAL_ALLOC,status=%s",
238 get_status_name( result
->virtual_alloc
.status
));
239 dump_uint64( ",addr=", &result
->virtual_alloc
.addr
);
240 dump_uint64( ",size=", &result
->virtual_alloc
.size
);
242 case APC_VIRTUAL_FREE
:
243 fprintf( stderr
, "APC_VIRTUAL_FREE,status=%s",
244 get_status_name( result
->virtual_free
.status
));
245 dump_uint64( ",addr=", &result
->virtual_free
.addr
);
246 dump_uint64( ",size=", &result
->virtual_free
.size
);
248 case APC_VIRTUAL_QUERY
:
249 fprintf( stderr
, "APC_VIRTUAL_QUERY,status=%s",
250 get_status_name( result
->virtual_query
.status
));
251 dump_uint64( ",base=", &result
->virtual_query
.base
);
252 dump_uint64( ",alloc_base=", &result
->virtual_query
.alloc_base
);
253 dump_uint64( ",size=", &result
->virtual_query
.size
);
254 fprintf( stderr
, ",state=%x,prot=%x,alloc_prot=%x,alloc_type=%x",
255 result
->virtual_query
.state
, result
->virtual_query
.prot
,
256 result
->virtual_query
.alloc_prot
, result
->virtual_query
.alloc_type
);
258 case APC_VIRTUAL_PROTECT
:
259 fprintf( stderr
, "APC_VIRTUAL_PROTECT,status=%s",
260 get_status_name( result
->virtual_protect
.status
));
261 dump_uint64( ",addr=", &result
->virtual_protect
.addr
);
262 dump_uint64( ",size=", &result
->virtual_protect
.size
);
263 fprintf( stderr
, ",prot=%x", result
->virtual_protect
.prot
);
265 case APC_VIRTUAL_FLUSH
:
266 fprintf( stderr
, "APC_VIRTUAL_FLUSH,status=%s",
267 get_status_name( result
->virtual_flush
.status
));
268 dump_uint64( ",addr=", &result
->virtual_flush
.addr
);
269 dump_uint64( ",size=", &result
->virtual_flush
.size
);
271 case APC_VIRTUAL_LOCK
:
272 fprintf( stderr
, "APC_VIRTUAL_LOCK,status=%s",
273 get_status_name( result
->virtual_lock
.status
));
274 dump_uint64( ",addr=", &result
->virtual_lock
.addr
);
275 dump_uint64( ",size=", &result
->virtual_lock
.size
);
277 case APC_VIRTUAL_UNLOCK
:
278 fprintf( stderr
, "APC_VIRTUAL_UNLOCK,status=%s",
279 get_status_name( result
->virtual_unlock
.status
));
280 dump_uint64( ",addr=", &result
->virtual_unlock
.addr
);
281 dump_uint64( ",size=", &result
->virtual_unlock
.size
);
284 fprintf( stderr
, "APC_MAP_VIEW,status=%s",
285 get_status_name( result
->map_view
.status
));
286 dump_uint64( ",addr=", &result
->map_view
.addr
);
287 dump_uint64( ",size=", &result
->map_view
.size
);
290 fprintf( stderr
, "APC_UNMAP_VIEW,status=%s",
291 get_status_name( result
->unmap_view
.status
) );
293 case APC_CREATE_THREAD
:
294 fprintf( stderr
, "APC_CREATE_THREAD,status=%s,tid=%04x,handle=%04x",
295 get_status_name( result
->create_thread
.status
),
296 result
->create_thread
.tid
, result
->create_thread
.handle
);
299 fprintf( stderr
, "type=%u", result
->type
);
302 fputc( '}', stderr
);
305 static void dump_async_data( const char *prefix
, const async_data_t
*data
)
307 fprintf( stderr
, "%s{handle=%04x,event=%04x", prefix
, data
->handle
, data
->event
);
308 dump_uint64( ",callback=", &data
->callback
);
309 dump_uint64( ",iosb=", &data
->iosb
);
310 dump_uint64( ",arg=", &data
->arg
);
311 dump_uint64( ",cvalue=", &data
->cvalue
);
312 fputc( '}', stderr
);
315 static void dump_irp_params( const char *prefix
, const irp_params_t
*data
)
320 fprintf( stderr
, "%s{major=READ,key=%08x", prefix
, data
->read
.key
);
321 dump_uint64( ",pos=", &data
->read
.pos
);
322 fputc( '}', stderr
);
325 fprintf( stderr
, "%s{major=WRITE,key=%08x", prefix
, data
->write
.key
);
326 dump_uint64( ",pos=", &data
->write
.pos
);
327 fputc( '}', stderr
);
329 case IRP_MJ_FLUSH_BUFFERS
:
330 fprintf( stderr
, "%s{major=FLUSH_BUFFERS}", prefix
);
332 case IRP_MJ_DEVICE_CONTROL
:
333 fprintf( stderr
, "%s{major=DEVICE_CONTROL", prefix
);
334 dump_ioctl_code( ",code=", &data
->ioctl
.code
);
335 fputc( '}', stderr
);
338 fprintf( stderr
, "%s{major=%u}", prefix
, data
->major
);
343 static void dump_hw_input( const char *prefix
, const hw_input_t
*input
)
348 fprintf( stderr
, "%s{type=MOUSE,x=%d,y=%d,data=%08x,flags=%08x,time=%u",
349 prefix
, input
->mouse
.x
, input
->mouse
.y
, input
->mouse
.data
, input
->mouse
.flags
,
351 dump_uint64( ",info=", &input
->mouse
.info
);
352 fputc( '}', stderr
);
355 fprintf( stderr
, "%s{type=KEYBOARD,vkey=%04hx,scan=%04hx,flags=%08x,time=%u",
356 prefix
, input
->kbd
.vkey
, input
->kbd
.scan
, input
->kbd
.flags
, input
->kbd
.time
);
357 dump_uint64( ",info=", &input
->kbd
.info
);
358 fputc( '}', stderr
);
361 fprintf( stderr
, "%s{type=HARDWARE,msg=%04x", prefix
, input
->hw
.msg
);
362 dump_uint64( ",lparam=", &input
->hw
.lparam
);
363 fputc( '}', stderr
);
366 fprintf( stderr
, "%s{type=%04x}", prefix
, input
->type
);
371 static void dump_luid( const char *prefix
, const luid_t
*luid
)
373 fprintf( stderr
, "%s%d.%u", prefix
, luid
->high_part
, luid
->low_part
);
376 static void dump_varargs_ints( const char *prefix
, data_size_t size
)
378 const int *data
= cur_data
;
379 data_size_t len
= size
/ sizeof(*data
);
381 fprintf( stderr
,"%s{", prefix
);
384 fprintf( stderr
, "%d", *data
++ );
385 if (--len
) fputc( ',', stderr
);
387 fputc( '}', stderr
);
391 static void dump_varargs_uints64( const char *prefix
, data_size_t size
)
393 const unsigned __int64
*data
= cur_data
;
394 data_size_t len
= size
/ sizeof(*data
);
396 fprintf( stderr
,"%s{", prefix
);
399 dump_uint64( "", data
++ );
400 if (--len
) fputc( ',', stderr
);
402 fputc( '}', stderr
);
406 static void dump_varargs_apc_result( const char *prefix
, data_size_t size
)
408 const apc_result_t
*result
= cur_data
;
410 if (size
>= sizeof(*result
))
412 dump_apc_result( prefix
, result
);
413 size
= sizeof(*result
);
418 static void dump_varargs_select_op( const char *prefix
, data_size_t size
)
424 fprintf( stderr
, "%s{}", prefix
);
427 memset( &data
, 0, sizeof(data
) );
428 memcpy( &data
, cur_data
, min( size
, sizeof(data
) ));
430 fprintf( stderr
, "%s{", prefix
);
434 fprintf( stderr
, "NONE" );
437 case SELECT_WAIT_ALL
:
438 fprintf( stderr
, "%s", data
.op
== SELECT_WAIT
? "WAIT" : "WAIT_ALL" );
439 if (size
> offsetof( select_op_t
, wait
.handles
))
440 dump_handles( ",handles=", data
.wait
.handles
,
441 min( size
, sizeof(data
.wait
) ) - offsetof( select_op_t
, wait
.handles
));
443 case SELECT_SIGNAL_AND_WAIT
:
444 fprintf( stderr
, "SIGNAL_AND_WAIT,signal=%04x,wait=%04x",
445 data
.signal_and_wait
.signal
, data
.signal_and_wait
.wait
);
447 case SELECT_KEYED_EVENT_WAIT
:
448 case SELECT_KEYED_EVENT_RELEASE
:
449 fprintf( stderr
, "KEYED_EVENT_%s,handle=%04x",
450 data
.op
== SELECT_KEYED_EVENT_WAIT
? "WAIT" : "RELEASE",
451 data
.keyed_event
.handle
);
452 dump_uint64( ",key=", &data
.keyed_event
.key
);
455 fprintf( stderr
, "op=%u", data
.op
);
458 fputc( '}', stderr
);
462 static void dump_varargs_user_handles( const char *prefix
, data_size_t size
)
464 const user_handle_t
*data
= cur_data
;
465 data_size_t len
= size
/ sizeof(*data
);
467 fprintf( stderr
,"%s{", prefix
);
470 fprintf( stderr
, "%08x", *data
++ );
471 if (--len
) fputc( ',', stderr
);
473 fputc( '}', stderr
);
477 static void dump_varargs_bytes( const char *prefix
, data_size_t size
)
479 const unsigned char *data
= cur_data
;
480 data_size_t len
= min( 1024, size
);
482 fprintf( stderr
,"%s{", prefix
);
485 fprintf( stderr
, "%02x", *data
++ );
486 if (--len
) fputc( ',', stderr
);
488 if (size
> 1024) fprintf( stderr
, "...(total %u)", size
);
489 fputc( '}', stderr
);
493 static void dump_varargs_string( const char *prefix
, data_size_t size
)
495 fprintf( stderr
, "%s\"%.*s\"", prefix
, (int)size
, (const char *)cur_data
);
499 static void dump_varargs_unicode_str( const char *prefix
, data_size_t size
)
501 fprintf( stderr
, "%sL\"", prefix
);
502 dump_strW( cur_data
, size
/ sizeof(WCHAR
), stderr
, "\"\"" );
503 fputc( '\"', stderr
);
507 static void dump_varargs_context( const char *prefix
, data_size_t size
)
509 const context_t
*context
= cur_data
;
515 fprintf( stderr
, "%s{}", prefix
);
518 size
= min( size
, sizeof(ctx
) );
519 memset( &ctx
, 0, sizeof(ctx
) );
520 memcpy( &ctx
, context
, size
);
522 fprintf( stderr
,"%s{", prefix
);
523 dump_cpu_type( "cpu=", &ctx
.cpu
);
527 if (ctx
.flags
& SERVER_CTX_CONTROL
)
528 fprintf( stderr
, ",eip=%08x,esp=%08x,ebp=%08x,eflags=%08x,cs=%04x,ss=%04x",
529 ctx
.ctl
.i386_regs
.eip
, ctx
.ctl
.i386_regs
.esp
, ctx
.ctl
.i386_regs
.ebp
,
530 ctx
.ctl
.i386_regs
.eflags
, ctx
.ctl
.i386_regs
.cs
, ctx
.ctl
.i386_regs
.ss
);
531 if (ctx
.flags
& SERVER_CTX_SEGMENTS
)
532 fprintf( stderr
, ",ds=%04x,es=%04x,fs=%04x,gs=%04x",
533 ctx
.seg
.i386_regs
.ds
, ctx
.seg
.i386_regs
.es
,
534 ctx
.seg
.i386_regs
.fs
, ctx
.seg
.i386_regs
.gs
);
535 if (ctx
.flags
& SERVER_CTX_INTEGER
)
536 fprintf( stderr
, ",eax=%08x,ebx=%08x,ecx=%08x,edx=%08x,esi=%08x,edi=%08x",
537 ctx
.integer
.i386_regs
.eax
, ctx
.integer
.i386_regs
.ebx
, ctx
.integer
.i386_regs
.ecx
,
538 ctx
.integer
.i386_regs
.edx
, ctx
.integer
.i386_regs
.esi
, ctx
.integer
.i386_regs
.edi
);
539 if (ctx
.flags
& SERVER_CTX_DEBUG_REGISTERS
)
540 fprintf( stderr
, ",dr0=%08x,dr1=%08x,dr2=%08x,dr3=%08x,dr6=%08x,dr7=%08x",
541 ctx
.debug
.i386_regs
.dr0
, ctx
.debug
.i386_regs
.dr1
, ctx
.debug
.i386_regs
.dr2
,
542 ctx
.debug
.i386_regs
.dr3
, ctx
.debug
.i386_regs
.dr6
, ctx
.debug
.i386_regs
.dr7
);
543 if (ctx
.flags
& SERVER_CTX_FLOATING_POINT
)
545 fprintf( stderr
, ",fp.ctrl=%08x,fp.status=%08x,fp.tag=%08x,fp.err_off=%08x,fp.err_sel=%08x",
546 ctx
.fp
.i386_regs
.ctrl
, ctx
.fp
.i386_regs
.status
, ctx
.fp
.i386_regs
.tag
,
547 ctx
.fp
.i386_regs
.err_off
, ctx
.fp
.i386_regs
.err_sel
);
548 fprintf( stderr
, ",fp.data_off=%08x,fp.data_sel=%08x,fp.cr0npx=%08x",
549 ctx
.fp
.i386_regs
.data_off
, ctx
.fp
.i386_regs
.data_sel
, ctx
.fp
.i386_regs
.cr0npx
);
550 for (i
= 0; i
< 8; i
++)
551 fprintf( stderr
, ",fp.reg%u=%Lg", i
, *(long double *)&ctx
.fp
.i386_regs
.regs
[10*i
] );
553 if (ctx
.flags
& SERVER_CTX_EXTENDED_REGISTERS
)
555 fprintf( stderr
, ",extended=" );
556 dump_uints( (const int *)ctx
.ext
.i386_regs
, sizeof(ctx
.ext
.i386_regs
) / sizeof(int) );
560 if (ctx
.flags
& SERVER_CTX_CONTROL
)
562 dump_uint64( ",rip=", &ctx
.ctl
.x86_64_regs
.rip
);
563 dump_uint64( ",rbp=", &ctx
.ctl
.x86_64_regs
.rbp
);
564 dump_uint64( ",rsp=", &ctx
.ctl
.x86_64_regs
.rsp
);
565 fprintf( stderr
, ",cs=%04x,ss=%04x,flags=%08x",
566 ctx
.ctl
.x86_64_regs
.cs
, ctx
.ctl
.x86_64_regs
.ss
, ctx
.ctl
.x86_64_regs
.flags
);
568 if (ctx
.flags
& SERVER_CTX_INTEGER
)
570 dump_uint64( ",rax=", &ctx
.integer
.x86_64_regs
.rax
);
571 dump_uint64( ",rbx=", &ctx
.integer
.x86_64_regs
.rbx
);
572 dump_uint64( ",rcx=", &ctx
.integer
.x86_64_regs
.rcx
);
573 dump_uint64( ",rdx=", &ctx
.integer
.x86_64_regs
.rdx
);
574 dump_uint64( ",rsi=", &ctx
.integer
.x86_64_regs
.rsi
);
575 dump_uint64( ",rdi=", &ctx
.integer
.x86_64_regs
.rdi
);
576 dump_uint64( ",r8=", &ctx
.integer
.x86_64_regs
.r8
);
577 dump_uint64( ",r9=", &ctx
.integer
.x86_64_regs
.r9
);
578 dump_uint64( ",r10=", &ctx
.integer
.x86_64_regs
.r10
);
579 dump_uint64( ",r11=", &ctx
.integer
.x86_64_regs
.r11
);
580 dump_uint64( ",r12=", &ctx
.integer
.x86_64_regs
.r12
);
581 dump_uint64( ",r13=", &ctx
.integer
.x86_64_regs
.r13
);
582 dump_uint64( ",r14=", &ctx
.integer
.x86_64_regs
.r14
);
583 dump_uint64( ",r15=", &ctx
.integer
.x86_64_regs
.r15
);
585 if (ctx
.flags
& SERVER_CTX_SEGMENTS
)
586 fprintf( stderr
, ",ds=%04x,es=%04x,fs=%04x,gs=%04x",
587 ctx
.seg
.x86_64_regs
.ds
, ctx
.seg
.x86_64_regs
.es
,
588 ctx
.seg
.x86_64_regs
.fs
, ctx
.seg
.x86_64_regs
.gs
);
589 if (ctx
.flags
& SERVER_CTX_DEBUG_REGISTERS
)
591 dump_uint64( ",dr0=", &ctx
.debug
.x86_64_regs
.dr0
);
592 dump_uint64( ",dr1=", &ctx
.debug
.x86_64_regs
.dr1
);
593 dump_uint64( ",dr2=", &ctx
.debug
.x86_64_regs
.dr2
);
594 dump_uint64( ",dr3=", &ctx
.debug
.x86_64_regs
.dr3
);
595 dump_uint64( ",dr6=", &ctx
.debug
.x86_64_regs
.dr6
);
596 dump_uint64( ",dr7=", &ctx
.debug
.x86_64_regs
.dr7
);
598 if (ctx
.flags
& SERVER_CTX_FLOATING_POINT
)
600 for (i
= 0; i
< 32; i
++)
601 fprintf( stderr
, ",fp%u=%08x%08x%08x%08x", i
,
602 (unsigned int)(ctx
.fp
.x86_64_regs
.fpregs
[i
].high
>> 32),
603 (unsigned int)ctx
.fp
.x86_64_regs
.fpregs
[i
].high
,
604 (unsigned int)(ctx
.fp
.x86_64_regs
.fpregs
[i
].low
>> 32),
605 (unsigned int)ctx
.fp
.x86_64_regs
.fpregs
[i
].low
);
609 if (ctx
.flags
& SERVER_CTX_CONTROL
)
610 fprintf( stderr
, ",iar=%08x,msr=%08x,ctr=%08x,lr=%08x,dar=%08x,dsisr=%08x,trap=%08x",
611 ctx
.ctl
.powerpc_regs
.iar
, ctx
.ctl
.powerpc_regs
.msr
, ctx
.ctl
.powerpc_regs
.ctr
,
612 ctx
.ctl
.powerpc_regs
.lr
, ctx
.ctl
.powerpc_regs
.dar
, ctx
.ctl
.powerpc_regs
.dsisr
,
613 ctx
.ctl
.powerpc_regs
.trap
);
614 if (ctx
.flags
& SERVER_CTX_INTEGER
)
616 for (i
= 0; i
< 32; i
++) fprintf( stderr
, ",gpr%u=%08x", i
, ctx
.integer
.powerpc_regs
.gpr
[i
] );
617 fprintf( stderr
, ",cr=%08x,xer=%08x",
618 ctx
.integer
.powerpc_regs
.cr
, ctx
.integer
.powerpc_regs
.xer
);
620 if (ctx
.flags
& SERVER_CTX_DEBUG_REGISTERS
)
621 for (i
= 0; i
< 8; i
++) fprintf( stderr
, ",dr%u=%08x", i
, ctx
.debug
.powerpc_regs
.dr
[i
] );
622 if (ctx
.flags
& SERVER_CTX_FLOATING_POINT
)
624 for (i
= 0; i
< 32; i
++) fprintf( stderr
, ",fpr%u=%g", i
, ctx
.fp
.powerpc_regs
.fpr
[i
] );
625 fprintf( stderr
, ",fpscr=%g", ctx
.fp
.powerpc_regs
.fpscr
);
629 if (ctx
.flags
& SERVER_CTX_CONTROL
)
630 fprintf( stderr
, ",sp=%08x,lr=%08x,pc=%08x,cpsr=%08x",
631 ctx
.ctl
.arm_regs
.sp
, ctx
.ctl
.arm_regs
.lr
,
632 ctx
.ctl
.arm_regs
.pc
, ctx
.ctl
.arm_regs
.cpsr
);
633 if (ctx
.flags
& SERVER_CTX_INTEGER
)
634 for (i
= 0; i
< 13; i
++) fprintf( stderr
, ",r%u=%08x", i
, ctx
.integer
.arm_regs
.r
[i
] );
637 if (ctx
.flags
& SERVER_CTX_CONTROL
)
639 dump_uint64( ",sp=", &ctx
.ctl
.arm64_regs
.sp
);
640 dump_uint64( ",pc=", &ctx
.ctl
.arm64_regs
.pc
);
641 dump_uint64( ",pstate=", &ctx
.ctl
.arm64_regs
.pstate
);
643 if (ctx
.flags
& SERVER_CTX_INTEGER
)
645 dump_uint64( ",x0=", &ctx
.integer
.arm64_regs
.x
[0] );
646 dump_uint64( ",x1=", &ctx
.integer
.arm64_regs
.x
[1] );
647 dump_uint64( ",x2=", &ctx
.integer
.arm64_regs
.x
[2] );
648 dump_uint64( ",x3=", &ctx
.integer
.arm64_regs
.x
[3] );
649 dump_uint64( ",x4=", &ctx
.integer
.arm64_regs
.x
[4] );
650 dump_uint64( ",x5=", &ctx
.integer
.arm64_regs
.x
[5] );
651 dump_uint64( ",x6=", &ctx
.integer
.arm64_regs
.x
[6] );
652 dump_uint64( ",x7=", &ctx
.integer
.arm64_regs
.x
[7] );
653 dump_uint64( ",x8=", &ctx
.integer
.arm64_regs
.x
[8] );
654 dump_uint64( ",x9=", &ctx
.integer
.arm64_regs
.x
[9] );
655 dump_uint64( ",x10=", &ctx
.integer
.arm64_regs
.x
[10] );
656 dump_uint64( ",x11=", &ctx
.integer
.arm64_regs
.x
[11] );
657 dump_uint64( ",x12=", &ctx
.integer
.arm64_regs
.x
[12] );
658 dump_uint64( ",x13=", &ctx
.integer
.arm64_regs
.x
[13] );
659 dump_uint64( ",x14=", &ctx
.integer
.arm64_regs
.x
[14] );
660 dump_uint64( ",x15=", &ctx
.integer
.arm64_regs
.x
[15] );
661 dump_uint64( ",x16=", &ctx
.integer
.arm64_regs
.x
[16] );
662 dump_uint64( ",x17=", &ctx
.integer
.arm64_regs
.x
[17] );
663 dump_uint64( ",x18=", &ctx
.integer
.arm64_regs
.x
[18] );
664 dump_uint64( ",x19=", &ctx
.integer
.arm64_regs
.x
[19] );
665 dump_uint64( ",x20=", &ctx
.integer
.arm64_regs
.x
[20] );
666 dump_uint64( ",x21=", &ctx
.integer
.arm64_regs
.x
[21] );
667 dump_uint64( ",x22=", &ctx
.integer
.arm64_regs
.x
[22] );
668 dump_uint64( ",x23=", &ctx
.integer
.arm64_regs
.x
[23] );
669 dump_uint64( ",x24=", &ctx
.integer
.arm64_regs
.x
[24] );
670 dump_uint64( ",x25=", &ctx
.integer
.arm64_regs
.x
[25] );
671 dump_uint64( ",x26=", &ctx
.integer
.arm64_regs
.x
[26] );
672 dump_uint64( ",x27=", &ctx
.integer
.arm64_regs
.x
[27] );
673 dump_uint64( ",x28=", &ctx
.integer
.arm64_regs
.x
[28] );
674 dump_uint64( ",x29=", &ctx
.integer
.arm64_regs
.x
[29] );
675 dump_uint64( ",x30=", &ctx
.integer
.arm64_regs
.x
[30] );
679 fputc( '}', stderr
);
683 static void dump_varargs_debug_event( const char *prefix
, data_size_t size
)
690 fprintf( stderr
, "%s{}", prefix
);
693 size
= min( size
, sizeof(event
) );
694 memset( &event
, 0, sizeof(event
) );
695 memcpy( &event
, cur_data
, size
);
699 case EXCEPTION_DEBUG_EVENT
:
700 fprintf( stderr
, "%s{exception,first=%d,exc_code=%08x,flags=%08x", prefix
,
701 event
.exception
.first
, event
.exception
.exc_code
, event
.exception
.flags
);
702 dump_uint64( ",record=", &event
.exception
.record
);
703 dump_uint64( ",address=", &event
.exception
.address
);
704 fprintf( stderr
, ",params={" );
705 event
.exception
.nb_params
= min( event
.exception
.nb_params
, EXCEPTION_MAXIMUM_PARAMETERS
);
706 for (i
= 0; i
< event
.exception
.nb_params
; i
++)
708 dump_uint64( "", &event
.exception
.params
[i
] );
709 if (i
< event
.exception
.nb_params
) fputc( ',', stderr
);
711 fprintf( stderr
, "}}" );
713 case CREATE_THREAD_DEBUG_EVENT
:
714 fprintf( stderr
, "%s{create_thread,thread=%04x", prefix
, event
.create_thread
.handle
);
715 dump_uint64( ",teb=", &event
.create_thread
.teb
);
716 dump_uint64( ",start=", &event
.create_thread
.start
);
717 fputc( '}', stderr
);
719 case CREATE_PROCESS_DEBUG_EVENT
:
720 fprintf( stderr
, "%s{create_process,file=%04x,process=%04x,thread=%04x", prefix
,
721 event
.create_process
.file
, event
.create_process
.process
,
722 event
.create_process
.thread
);
723 dump_uint64( ",base=", &event
.create_process
.base
);
724 fprintf( stderr
, ",offset=%d,size=%d",
725 event
.create_process
.dbg_offset
, event
.create_process
.dbg_size
);
726 dump_uint64( ",teb=", &event
.create_process
.teb
);
727 dump_uint64( ",start=", &event
.create_process
.start
);
728 dump_uint64( ",name=", &event
.create_process
.name
);
729 fprintf( stderr
, ",unicode=%d}", event
.create_process
.unicode
);
731 case EXIT_THREAD_DEBUG_EVENT
:
732 fprintf( stderr
, "%s{exit_thread,code=%d}", prefix
, event
.exit
.exit_code
);
734 case EXIT_PROCESS_DEBUG_EVENT
:
735 fprintf( stderr
, "%s{exit_process,code=%d}", prefix
, event
.exit
.exit_code
);
737 case LOAD_DLL_DEBUG_EVENT
:
738 fprintf( stderr
, "%s{load_dll,file=%04x", prefix
, event
.load_dll
.handle
);
739 dump_uint64( ",base=", &event
.load_dll
.base
);
740 fprintf( stderr
, ",offset=%d,size=%d",
741 event
.load_dll
.dbg_offset
, event
.load_dll
.dbg_size
);
742 dump_uint64( ",name=", &event
.load_dll
.name
);
743 fprintf( stderr
, ",unicode=%d}", event
.load_dll
.unicode
);
745 case UNLOAD_DLL_DEBUG_EVENT
:
746 fprintf( stderr
, "%s{unload_dll", prefix
);
747 dump_uint64( ",base=", &event
.unload_dll
.base
);
748 fputc( '}', stderr
);
750 case 0: /* zero is the code returned on timeouts */
751 fprintf( stderr
, "%s{}", prefix
);
754 fprintf( stderr
, "%s{code=??? (%d)}", prefix
, event
.code
);
760 /* dump a unicode string contained in a buffer; helper for dump_varargs_startup_info */
761 static data_size_t
dump_inline_unicode_string( const char *prefix
, data_size_t pos
, data_size_t len
, data_size_t total_size
)
763 fputs( prefix
, stderr
);
764 if (pos
>= total_size
) return pos
;
765 if (len
> total_size
- pos
) len
= total_size
- pos
;
766 len
/= sizeof(WCHAR
);
767 dump_strW( (const WCHAR
*)cur_data
+ pos
/sizeof(WCHAR
), len
, stderr
, "\"\"" );
768 return pos
+ len
* sizeof(WCHAR
);
771 static void dump_varargs_startup_info( const char *prefix
, data_size_t size
)
774 data_size_t pos
= sizeof(info
);
776 memset( &info
, 0, sizeof(info
) );
777 memcpy( &info
, cur_data
, min( size
, sizeof(info
) ));
780 "%s{debug_flags=%x,console_flags=%x,console=%04x,hstdin=%04x,hstdout=%04x,hstderr=%04x,"
781 "x=%u,y=%u,xsize=%u,ysize=%u,xchars=%u,ychars=%u,attribute=%02x,flags=%x,show=%u",
782 prefix
, info
.debug_flags
, info
.console_flags
, info
.console
,
783 info
.hstdin
, info
.hstdout
, info
.hstderr
, info
.x
, info
.y
, info
.xsize
, info
.ysize
,
784 info
.xchars
, info
.ychars
, info
.attribute
, info
.flags
, info
.show
);
785 pos
= dump_inline_unicode_string( ",curdir=L\"", pos
, info
.curdir_len
, size
);
786 pos
= dump_inline_unicode_string( "\",dllpath=L\"", pos
, info
.dllpath_len
, size
);
787 pos
= dump_inline_unicode_string( "\",imagepath=L\"", pos
, info
.imagepath_len
, size
);
788 pos
= dump_inline_unicode_string( "\",cmdline=L\"", pos
, info
.cmdline_len
, size
);
789 pos
= dump_inline_unicode_string( "\",title=L\"", pos
, info
.title_len
, size
);
790 pos
= dump_inline_unicode_string( "\",desktop=L\"", pos
, info
.desktop_len
, size
);
791 pos
= dump_inline_unicode_string( "\",shellinfo=L\"", pos
, info
.shellinfo_len
, size
);
792 pos
= dump_inline_unicode_string( "\",runtime=L\"", pos
, info
.runtime_len
, size
);
793 fprintf( stderr
, "\"}" );
797 static void dump_varargs_input_records( const char *prefix
, data_size_t size
)
799 const INPUT_RECORD
*rec
= cur_data
;
800 data_size_t len
= size
/ sizeof(*rec
);
802 fprintf( stderr
,"%s{", prefix
);
805 fprintf( stderr
, "{%04x,...}", rec
->EventType
);
807 if (--len
) fputc( ',', stderr
);
809 fputc( '}', stderr
);
813 static void dump_varargs_rectangles( const char *prefix
, data_size_t size
)
815 const rectangle_t
*rect
= cur_data
;
816 data_size_t len
= size
/ sizeof(*rect
);
818 fprintf( stderr
,"%s{", prefix
);
821 dump_rectangle( "", rect
++ );
822 if (--len
) fputc( ',', stderr
);
824 fputc( '}', stderr
);
828 static void dump_varargs_message_data( const char *prefix
, data_size_t size
)
830 /* FIXME: dump the structured data */
831 dump_varargs_bytes( prefix
, size
);
834 static void dump_varargs_properties( const char *prefix
, data_size_t size
)
836 const property_data_t
*prop
= cur_data
;
837 data_size_t len
= size
/ sizeof(*prop
);
839 fprintf( stderr
,"%s{", prefix
);
842 fprintf( stderr
, "{atom=%04x,str=%d", prop
->atom
, prop
->string
);
843 dump_uint64( ",data=", &prop
->data
);
844 fputc( '}', stderr
);
846 if (--len
) fputc( ',', stderr
);
848 fputc( '}', stderr
);
852 static void dump_varargs_LUID_AND_ATTRIBUTES( const char *prefix
, data_size_t size
)
854 const LUID_AND_ATTRIBUTES
*lat
= cur_data
;
855 data_size_t len
= size
/ sizeof(*lat
);
857 fprintf( stderr
,"%s{", prefix
);
860 fprintf( stderr
, "{luid=%08x%08x,attr=%x}",
861 lat
->Luid
.HighPart
, lat
->Luid
.LowPart
, lat
->Attributes
);
863 if (--len
) fputc( ',', stderr
);
865 fputc( '}', stderr
);
869 static void dump_inline_sid( const char *prefix
, const SID
*sid
, data_size_t size
)
874 if ((FIELD_OFFSET(SID
, SubAuthority
[0]) > size
) ||
875 (FIELD_OFFSET(SID
, SubAuthority
[sid
->SubAuthorityCount
]) > size
))
877 fprintf( stderr
, "<invalid sid>" );
881 fprintf( stderr
,"%s{", prefix
);
882 fprintf( stderr
, "S-%u-%u", sid
->Revision
, MAKELONG(
883 MAKEWORD( sid
->IdentifierAuthority
.Value
[5],
884 sid
->IdentifierAuthority
.Value
[4] ),
885 MAKEWORD( sid
->IdentifierAuthority
.Value
[3],
886 sid
->IdentifierAuthority
.Value
[2] ) ) );
887 for (i
= 0; i
< sid
->SubAuthorityCount
; i
++)
888 fprintf( stderr
, "-%u", sid
->SubAuthority
[i
] );
889 fputc( '}', stderr
);
892 static void dump_varargs_SID( const char *prefix
, data_size_t size
)
894 const SID
*sid
= cur_data
;
895 dump_inline_sid( prefix
, sid
, size
);
899 static void dump_inline_acl( const char *prefix
, const ACL
*acl
, data_size_t size
)
901 const ACE_HEADER
*ace
;
904 fprintf( stderr
,"%s{", prefix
);
907 if (size
< sizeof(ACL
))
909 fprintf( stderr
, "<invalid acl>}" );
913 ace
= (const ACE_HEADER
*)(acl
+ 1);
914 for (i
= 0; i
< acl
->AceCount
; i
++)
916 const SID
*sid
= NULL
;
917 data_size_t sid_size
= 0;
919 if (size
< sizeof(ACE_HEADER
) || size
< ace
->AceSize
) break;
920 size
-= ace
->AceSize
;
921 if (i
!= 0) fputc( ',', stderr
);
922 fprintf( stderr
, "{AceType=" );
923 switch (ace
->AceType
)
925 case ACCESS_DENIED_ACE_TYPE
:
926 sid
= (const SID
*)&((const ACCESS_DENIED_ACE
*)ace
)->SidStart
;
927 sid_size
= ace
->AceSize
- FIELD_OFFSET(ACCESS_DENIED_ACE
, SidStart
);
928 fprintf( stderr
, "ACCESS_DENIED_ACE_TYPE,Mask=%x",
929 ((const ACCESS_DENIED_ACE
*)ace
)->Mask
);
931 case ACCESS_ALLOWED_ACE_TYPE
:
932 sid
= (const SID
*)&((const ACCESS_ALLOWED_ACE
*)ace
)->SidStart
;
933 sid_size
= ace
->AceSize
- FIELD_OFFSET(ACCESS_ALLOWED_ACE
, SidStart
);
934 fprintf( stderr
, "ACCESS_ALLOWED_ACE_TYPE,Mask=%x",
935 ((const ACCESS_ALLOWED_ACE
*)ace
)->Mask
);
937 case SYSTEM_AUDIT_ACE_TYPE
:
938 sid
= (const SID
*)&((const SYSTEM_AUDIT_ACE
*)ace
)->SidStart
;
939 sid_size
= ace
->AceSize
- FIELD_OFFSET(SYSTEM_AUDIT_ACE
, SidStart
);
940 fprintf( stderr
, "SYSTEM_AUDIT_ACE_TYPE,Mask=%x",
941 ((const SYSTEM_AUDIT_ACE
*)ace
)->Mask
);
943 case SYSTEM_ALARM_ACE_TYPE
:
944 sid
= (const SID
*)&((const SYSTEM_ALARM_ACE
*)ace
)->SidStart
;
945 sid_size
= ace
->AceSize
- FIELD_OFFSET(SYSTEM_ALARM_ACE
, SidStart
);
946 fprintf( stderr
, "SYSTEM_ALARM_ACE_TYPE,Mask=%x",
947 ((const SYSTEM_ALARM_ACE
*)ace
)->Mask
);
949 case SYSTEM_MANDATORY_LABEL_ACE_TYPE
:
950 sid
= (const SID
*)&((const SYSTEM_MANDATORY_LABEL_ACE
*)ace
)->SidStart
;
951 sid_size
= ace
->AceSize
- FIELD_OFFSET(SYSTEM_MANDATORY_LABEL_ACE
, SidStart
);
952 fprintf( stderr
, "SYSTEM_MANDATORY_LABEL_ACE_TYPE,Mask=%x",
953 ((const SYSTEM_MANDATORY_LABEL_ACE
*)ace
)->Mask
);
956 fprintf( stderr
, "unknown<%d>", ace
->AceType
);
959 fprintf( stderr
, ",AceFlags=%x", ace
->AceFlags
);
961 dump_inline_sid( ",Sid=", sid
, sid_size
);
962 ace
= (const ACE_HEADER
*)((const char *)ace
+ ace
->AceSize
);
963 fputc( '}', stderr
);
966 fputc( '}', stderr
);
969 static void dump_varargs_ACL( const char *prefix
, data_size_t size
)
971 const ACL
*acl
= cur_data
;
972 dump_inline_acl( prefix
, acl
, size
);
976 static void dump_inline_security_descriptor( const char *prefix
, const struct security_descriptor
*sd
, data_size_t size
)
978 fprintf( stderr
,"%s{", prefix
);
979 if (size
>= sizeof(struct security_descriptor
))
981 size_t offset
= sizeof(struct security_descriptor
);
982 fprintf( stderr
, "control=%08x", sd
->control
);
983 if ((sd
->owner_len
> FIELD_OFFSET(SID
, SubAuthority
[255])) || (offset
+ sd
->owner_len
> size
))
986 dump_inline_sid( ",owner=", (const SID
*)((const char *)sd
+ offset
), sd
->owner_len
);
988 fprintf( stderr
, ",owner=<not present>" );
989 offset
+= sd
->owner_len
;
990 if ((sd
->group_len
> FIELD_OFFSET(SID
, SubAuthority
[255])) || (offset
+ sd
->group_len
> size
))
993 dump_inline_sid( ",group=", (const SID
*)((const char *)sd
+ offset
), sd
->group_len
);
995 fprintf( stderr
, ",group=<not present>" );
996 offset
+= sd
->group_len
;
997 if ((sd
->sacl_len
>= MAX_ACL_LEN
) || (offset
+ sd
->sacl_len
> size
))
999 dump_inline_acl( ",sacl=", (const ACL
*)((const char *)sd
+ offset
), sd
->sacl_len
);
1000 offset
+= sd
->sacl_len
;
1001 if ((sd
->dacl_len
>= MAX_ACL_LEN
) || (offset
+ sd
->dacl_len
> size
))
1003 dump_inline_acl( ",dacl=", (const ACL
*)((const char *)sd
+ offset
), sd
->dacl_len
);
1004 offset
+= sd
->dacl_len
;
1006 fputc( '}', stderr
);
1009 static void dump_varargs_security_descriptor( const char *prefix
, data_size_t size
)
1011 const struct security_descriptor
*sd
= cur_data
;
1012 dump_inline_security_descriptor( prefix
, sd
, size
);
1013 remove_data( size
);
1016 static void dump_varargs_token_groups( const char *prefix
, data_size_t size
)
1018 const struct token_groups
*tg
= cur_data
;
1020 fprintf( stderr
,"%s{", prefix
);
1021 if (size
>= sizeof(struct token_groups
))
1023 size_t offset
= sizeof(*tg
);
1024 fprintf( stderr
, "count=%08x,", tg
->count
);
1025 if (tg
->count
* sizeof(unsigned int) <= size
)
1028 const unsigned int *attr
= (const unsigned int *)(tg
+ 1);
1030 offset
+= tg
->count
* sizeof(unsigned int);
1032 fputc( '[', stderr
);
1033 for (i
= 0; i
< tg
->count
; i
++)
1035 const SID
*sid
= (const SID
*)((const char *)cur_data
+ offset
);
1037 fputc( ',', stderr
);
1038 fputc( '{', stderr
);
1039 fprintf( stderr
, "attributes=%08x", attr
[i
] );
1040 dump_inline_sid( ",sid=", sid
, size
- offset
);
1041 if ((offset
+ FIELD_OFFSET(SID
, SubAuthority
[0]) > size
) ||
1042 (offset
+ FIELD_OFFSET(SID
, SubAuthority
[sid
->SubAuthorityCount
]) > size
))
1044 offset
+= FIELD_OFFSET(SID
, SubAuthority
[sid
->SubAuthorityCount
]);
1045 fputc( '}', stderr
);
1047 fputc( ']', stderr
);
1050 fputc( '}', stderr
);
1053 static void dump_varargs_object_attributes( const char *prefix
, data_size_t size
)
1055 const struct object_attributes
*objattr
= cur_data
;
1057 fprintf( stderr
,"%s{", prefix
);
1058 if (size
>= sizeof(struct object_attributes
))
1061 fprintf( stderr
, "rootdir=%04x", objattr
->rootdir
);
1062 if (objattr
->sd_len
> size
- sizeof(*objattr
) ||
1063 objattr
->name_len
> size
- sizeof(*objattr
) - objattr
->sd_len
)
1065 dump_inline_security_descriptor( ",sd=", (const struct security_descriptor
*)(objattr
+ 1), objattr
->sd_len
);
1066 str
= (const WCHAR
*)objattr
+ (sizeof(*objattr
) + objattr
->sd_len
) / sizeof(WCHAR
);
1067 fprintf( stderr
, ",name=L\"" );
1068 dump_strW( str
, objattr
->name_len
/ sizeof(WCHAR
), stderr
, "\"\"" );
1069 fputc( '\"', stderr
);
1070 remove_data( ((sizeof(*objattr
) + objattr
->sd_len
) / sizeof(WCHAR
)) * sizeof(WCHAR
) +
1071 objattr
->name_len
);
1073 fputc( '}', stderr
);
1076 static void dump_varargs_filesystem_event( const char *prefix
, data_size_t size
)
1078 static const char * const actions
[] = {
1090 fprintf( stderr
,"%s{", prefix
);
1093 const struct filesystem_event
*event
= cur_data
;
1094 data_size_t len
= (offsetof( struct filesystem_event
, name
[event
->len
] ) + sizeof(int)-1)
1095 / sizeof(int) * sizeof(int);
1096 if (size
< len
) break;
1097 if (event
->action
< sizeof(actions
)/sizeof(actions
[0]) && actions
[event
->action
])
1098 fprintf( stderr
, "{action=%s", actions
[event
->action
] );
1100 fprintf( stderr
, "{action=%u", event
->action
);
1101 fprintf( stderr
, ",name=\"%.*s\"}", event
->len
, event
->name
);
1104 if (size
)fputc( ',', stderr
);
1106 fputc( '}', stderr
);
1109 static void dump_varargs_rawinput_devices(const char *prefix
, data_size_t size
)
1111 const struct rawinput_device
*device
;
1113 fprintf( stderr
, "%s{", prefix
);
1114 while (size
>= sizeof(*device
))
1117 fprintf( stderr
, "{usage_page=%04x,usage=%04x,flags=%08x,target=%08x}",
1118 device
->usage_page
, device
->usage
, device
->flags
, device
->target
);
1119 size
-= sizeof(*device
);
1120 remove_data( sizeof(*device
) );
1121 if (size
) fputc( ',', stderr
);
1123 fputc( '}', stderr
);
1126 typedef void (*dump_func
)( const void *req
);
1128 /* Everything below this line is generated automatically by tools/make_requests */
1129 /* ### make_requests begin ### */
1131 static void dump_new_process_request( const struct new_process_request
*req
)
1133 fprintf( stderr
, " inherit_all=%d", req
->inherit_all
);
1134 fprintf( stderr
, ", create_flags=%08x", req
->create_flags
);
1135 fprintf( stderr
, ", socket_fd=%d", req
->socket_fd
);
1136 fprintf( stderr
, ", exe_file=%04x", req
->exe_file
);
1137 fprintf( stderr
, ", process_access=%08x", req
->process_access
);
1138 fprintf( stderr
, ", process_attr=%08x", req
->process_attr
);
1139 fprintf( stderr
, ", thread_access=%08x", req
->thread_access
);
1140 fprintf( stderr
, ", thread_attr=%08x", req
->thread_attr
);
1141 dump_cpu_type( ", cpu=", &req
->cpu
);
1142 fprintf( stderr
, ", info_size=%u", req
->info_size
);
1143 dump_varargs_startup_info( ", info=", min(cur_size
,req
->info_size
) );
1144 dump_varargs_unicode_str( ", env=", cur_size
);
1147 static void dump_new_process_reply( const struct new_process_reply
*req
)
1149 fprintf( stderr
, " info=%04x", req
->info
);
1150 fprintf( stderr
, ", pid=%04x", req
->pid
);
1151 fprintf( stderr
, ", phandle=%04x", req
->phandle
);
1152 fprintf( stderr
, ", tid=%04x", req
->tid
);
1153 fprintf( stderr
, ", thandle=%04x", req
->thandle
);
1156 static void dump_get_new_process_info_request( const struct get_new_process_info_request
*req
)
1158 fprintf( stderr
, " info=%04x", req
->info
);
1161 static void dump_get_new_process_info_reply( const struct get_new_process_info_reply
*req
)
1163 fprintf( stderr
, " success=%d", req
->success
);
1164 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1167 static void dump_new_thread_request( const struct new_thread_request
*req
)
1169 fprintf( stderr
, " access=%08x", req
->access
);
1170 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1171 fprintf( stderr
, ", suspend=%d", req
->suspend
);
1172 fprintf( stderr
, ", request_fd=%d", req
->request_fd
);
1175 static void dump_new_thread_reply( const struct new_thread_reply
*req
)
1177 fprintf( stderr
, " tid=%04x", req
->tid
);
1178 fprintf( stderr
, ", handle=%04x", req
->handle
);
1181 static void dump_get_startup_info_request( const struct get_startup_info_request
*req
)
1185 static void dump_get_startup_info_reply( const struct get_startup_info_reply
*req
)
1187 fprintf( stderr
, " exe_file=%04x", req
->exe_file
);
1188 fprintf( stderr
, ", info_size=%u", req
->info_size
);
1189 dump_varargs_startup_info( ", info=", min(cur_size
,req
->info_size
) );
1190 dump_varargs_unicode_str( ", env=", cur_size
);
1193 static void dump_init_process_done_request( const struct init_process_done_request
*req
)
1195 fprintf( stderr
, " gui=%d", req
->gui
);
1196 dump_uint64( ", module=", &req
->module
);
1197 dump_uint64( ", ldt_copy=", &req
->ldt_copy
);
1198 dump_uint64( ", entry=", &req
->entry
);
1201 static void dump_init_thread_request( const struct init_thread_request
*req
)
1203 fprintf( stderr
, " unix_pid=%d", req
->unix_pid
);
1204 fprintf( stderr
, ", unix_tid=%d", req
->unix_tid
);
1205 fprintf( stderr
, ", debug_level=%d", req
->debug_level
);
1206 dump_uint64( ", teb=", &req
->teb
);
1207 dump_uint64( ", entry=", &req
->entry
);
1208 fprintf( stderr
, ", reply_fd=%d", req
->reply_fd
);
1209 fprintf( stderr
, ", wait_fd=%d", req
->wait_fd
);
1210 dump_cpu_type( ", cpu=", &req
->cpu
);
1213 static void dump_init_thread_reply( const struct init_thread_reply
*req
)
1215 fprintf( stderr
, " pid=%04x", req
->pid
);
1216 fprintf( stderr
, ", tid=%04x", req
->tid
);
1217 dump_timeout( ", server_start=", &req
->server_start
);
1218 fprintf( stderr
, ", info_size=%u", req
->info_size
);
1219 fprintf( stderr
, ", version=%d", req
->version
);
1220 fprintf( stderr
, ", all_cpus=%08x", req
->all_cpus
);
1223 static void dump_terminate_process_request( const struct terminate_process_request
*req
)
1225 fprintf( stderr
, " handle=%04x", req
->handle
);
1226 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1229 static void dump_terminate_process_reply( const struct terminate_process_reply
*req
)
1231 fprintf( stderr
, " self=%d", req
->self
);
1234 static void dump_terminate_thread_request( const struct terminate_thread_request
*req
)
1236 fprintf( stderr
, " handle=%04x", req
->handle
);
1237 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1240 static void dump_terminate_thread_reply( const struct terminate_thread_reply
*req
)
1242 fprintf( stderr
, " self=%d", req
->self
);
1243 fprintf( stderr
, ", last=%d", req
->last
);
1246 static void dump_get_process_info_request( const struct get_process_info_request
*req
)
1248 fprintf( stderr
, " handle=%04x", req
->handle
);
1251 static void dump_get_process_info_reply( const struct get_process_info_reply
*req
)
1253 fprintf( stderr
, " pid=%04x", req
->pid
);
1254 fprintf( stderr
, ", ppid=%04x", req
->ppid
);
1255 dump_uint64( ", affinity=", &req
->affinity
);
1256 dump_uint64( ", peb=", &req
->peb
);
1257 dump_timeout( ", start_time=", &req
->start_time
);
1258 dump_timeout( ", end_time=", &req
->end_time
);
1259 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1260 fprintf( stderr
, ", priority=%d", req
->priority
);
1261 dump_cpu_type( ", cpu=", &req
->cpu
);
1262 fprintf( stderr
, ", debugger_present=%d", req
->debugger_present
);
1265 static void dump_set_process_info_request( const struct set_process_info_request
*req
)
1267 fprintf( stderr
, " handle=%04x", req
->handle
);
1268 fprintf( stderr
, ", mask=%d", req
->mask
);
1269 fprintf( stderr
, ", priority=%d", req
->priority
);
1270 dump_uint64( ", affinity=", &req
->affinity
);
1273 static void dump_get_thread_info_request( const struct get_thread_info_request
*req
)
1275 fprintf( stderr
, " handle=%04x", req
->handle
);
1276 fprintf( stderr
, ", tid_in=%04x", req
->tid_in
);
1279 static void dump_get_thread_info_reply( const struct get_thread_info_reply
*req
)
1281 fprintf( stderr
, " pid=%04x", req
->pid
);
1282 fprintf( stderr
, ", tid=%04x", req
->tid
);
1283 dump_uint64( ", teb=", &req
->teb
);
1284 dump_uint64( ", affinity=", &req
->affinity
);
1285 dump_timeout( ", creation_time=", &req
->creation_time
);
1286 dump_timeout( ", exit_time=", &req
->exit_time
);
1287 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1288 fprintf( stderr
, ", priority=%d", req
->priority
);
1289 fprintf( stderr
, ", last=%d", req
->last
);
1292 static void dump_set_thread_info_request( const struct set_thread_info_request
*req
)
1294 fprintf( stderr
, " handle=%04x", req
->handle
);
1295 fprintf( stderr
, ", mask=%d", req
->mask
);
1296 fprintf( stderr
, ", priority=%d", req
->priority
);
1297 dump_uint64( ", affinity=", &req
->affinity
);
1298 fprintf( stderr
, ", token=%04x", req
->token
);
1301 static void dump_get_dll_info_request( const struct get_dll_info_request
*req
)
1303 fprintf( stderr
, " handle=%04x", req
->handle
);
1304 dump_uint64( ", base_address=", &req
->base_address
);
1307 static void dump_get_dll_info_reply( const struct get_dll_info_reply
*req
)
1309 dump_uint64( " entry_point=", &req
->entry_point
);
1310 fprintf( stderr
, ", size=%u", req
->size
);
1311 fprintf( stderr
, ", filename_len=%u", req
->filename_len
);
1312 dump_varargs_unicode_str( ", filename=", cur_size
);
1315 static void dump_suspend_thread_request( const struct suspend_thread_request
*req
)
1317 fprintf( stderr
, " handle=%04x", req
->handle
);
1320 static void dump_suspend_thread_reply( const struct suspend_thread_reply
*req
)
1322 fprintf( stderr
, " count=%d", req
->count
);
1325 static void dump_resume_thread_request( const struct resume_thread_request
*req
)
1327 fprintf( stderr
, " handle=%04x", req
->handle
);
1330 static void dump_resume_thread_reply( const struct resume_thread_reply
*req
)
1332 fprintf( stderr
, " count=%d", req
->count
);
1335 static void dump_load_dll_request( const struct load_dll_request
*req
)
1337 fprintf( stderr
, " mapping=%04x", req
->mapping
);
1338 dump_uint64( ", base=", &req
->base
);
1339 dump_uint64( ", name=", &req
->name
);
1340 fprintf( stderr
, ", size=%u", req
->size
);
1341 fprintf( stderr
, ", dbg_offset=%d", req
->dbg_offset
);
1342 fprintf( stderr
, ", dbg_size=%d", req
->dbg_size
);
1343 dump_varargs_unicode_str( ", filename=", cur_size
);
1346 static void dump_unload_dll_request( const struct unload_dll_request
*req
)
1348 dump_uint64( " base=", &req
->base
);
1351 static void dump_queue_apc_request( const struct queue_apc_request
*req
)
1353 fprintf( stderr
, " handle=%04x", req
->handle
);
1354 dump_apc_call( ", call=", &req
->call
);
1357 static void dump_queue_apc_reply( const struct queue_apc_reply
*req
)
1359 fprintf( stderr
, " handle=%04x", req
->handle
);
1360 fprintf( stderr
, ", self=%d", req
->self
);
1363 static void dump_get_apc_result_request( const struct get_apc_result_request
*req
)
1365 fprintf( stderr
, " handle=%04x", req
->handle
);
1368 static void dump_get_apc_result_reply( const struct get_apc_result_reply
*req
)
1370 dump_apc_result( " result=", &req
->result
);
1373 static void dump_close_handle_request( const struct close_handle_request
*req
)
1375 fprintf( stderr
, " handle=%04x", req
->handle
);
1378 static void dump_set_handle_info_request( const struct set_handle_info_request
*req
)
1380 fprintf( stderr
, " handle=%04x", req
->handle
);
1381 fprintf( stderr
, ", flags=%d", req
->flags
);
1382 fprintf( stderr
, ", mask=%d", req
->mask
);
1385 static void dump_set_handle_info_reply( const struct set_handle_info_reply
*req
)
1387 fprintf( stderr
, " old_flags=%d", req
->old_flags
);
1390 static void dump_dup_handle_request( const struct dup_handle_request
*req
)
1392 fprintf( stderr
, " src_process=%04x", req
->src_process
);
1393 fprintf( stderr
, ", src_handle=%04x", req
->src_handle
);
1394 fprintf( stderr
, ", dst_process=%04x", req
->dst_process
);
1395 fprintf( stderr
, ", access=%08x", req
->access
);
1396 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1397 fprintf( stderr
, ", options=%08x", req
->options
);
1400 static void dump_dup_handle_reply( const struct dup_handle_reply
*req
)
1402 fprintf( stderr
, " handle=%04x", req
->handle
);
1403 fprintf( stderr
, ", self=%d", req
->self
);
1404 fprintf( stderr
, ", closed=%d", req
->closed
);
1407 static void dump_open_process_request( const struct open_process_request
*req
)
1409 fprintf( stderr
, " pid=%04x", req
->pid
);
1410 fprintf( stderr
, ", access=%08x", req
->access
);
1411 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1414 static void dump_open_process_reply( const struct open_process_reply
*req
)
1416 fprintf( stderr
, " handle=%04x", req
->handle
);
1419 static void dump_open_thread_request( const struct open_thread_request
*req
)
1421 fprintf( stderr
, " tid=%04x", req
->tid
);
1422 fprintf( stderr
, ", access=%08x", req
->access
);
1423 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1426 static void dump_open_thread_reply( const struct open_thread_reply
*req
)
1428 fprintf( stderr
, " handle=%04x", req
->handle
);
1431 static void dump_select_request( const struct select_request
*req
)
1433 fprintf( stderr
, " flags=%d", req
->flags
);
1434 dump_uint64( ", cookie=", &req
->cookie
);
1435 dump_timeout( ", timeout=", &req
->timeout
);
1436 fprintf( stderr
, ", prev_apc=%04x", req
->prev_apc
);
1437 dump_varargs_apc_result( ", result=", cur_size
);
1438 dump_varargs_select_op( ", data=", cur_size
);
1441 static void dump_select_reply( const struct select_reply
*req
)
1443 dump_timeout( " timeout=", &req
->timeout
);
1444 dump_apc_call( ", call=", &req
->call
);
1445 fprintf( stderr
, ", apc_handle=%04x", req
->apc_handle
);
1448 static void dump_create_event_request( const struct create_event_request
*req
)
1450 fprintf( stderr
, " access=%08x", req
->access
);
1451 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1452 fprintf( stderr
, ", manual_reset=%d", req
->manual_reset
);
1453 fprintf( stderr
, ", initial_state=%d", req
->initial_state
);
1454 dump_varargs_object_attributes( ", objattr=", cur_size
);
1457 static void dump_create_event_reply( const struct create_event_reply
*req
)
1459 fprintf( stderr
, " handle=%04x", req
->handle
);
1462 static void dump_event_op_request( const struct event_op_request
*req
)
1464 fprintf( stderr
, " handle=%04x", req
->handle
);
1465 fprintf( stderr
, ", op=%d", req
->op
);
1468 static void dump_query_event_request( const struct query_event_request
*req
)
1470 fprintf( stderr
, " handle=%04x", req
->handle
);
1473 static void dump_query_event_reply( const struct query_event_reply
*req
)
1475 fprintf( stderr
, " manual_reset=%d", req
->manual_reset
);
1476 fprintf( stderr
, ", state=%d", req
->state
);
1479 static void dump_open_event_request( const struct open_event_request
*req
)
1481 fprintf( stderr
, " access=%08x", req
->access
);
1482 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1483 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1484 dump_varargs_unicode_str( ", name=", cur_size
);
1487 static void dump_open_event_reply( const struct open_event_reply
*req
)
1489 fprintf( stderr
, " handle=%04x", req
->handle
);
1492 static void dump_create_keyed_event_request( const struct create_keyed_event_request
*req
)
1494 fprintf( stderr
, " access=%08x", req
->access
);
1495 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1496 dump_varargs_object_attributes( ", objattr=", cur_size
);
1499 static void dump_create_keyed_event_reply( const struct create_keyed_event_reply
*req
)
1501 fprintf( stderr
, " handle=%04x", req
->handle
);
1504 static void dump_open_keyed_event_request( const struct open_keyed_event_request
*req
)
1506 fprintf( stderr
, " access=%08x", req
->access
);
1507 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1508 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1509 dump_varargs_unicode_str( ", name=", cur_size
);
1512 static void dump_open_keyed_event_reply( const struct open_keyed_event_reply
*req
)
1514 fprintf( stderr
, " handle=%04x", req
->handle
);
1517 static void dump_create_mutex_request( const struct create_mutex_request
*req
)
1519 fprintf( stderr
, " access=%08x", req
->access
);
1520 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1521 fprintf( stderr
, ", owned=%d", req
->owned
);
1522 dump_varargs_object_attributes( ", objattr=", cur_size
);
1525 static void dump_create_mutex_reply( const struct create_mutex_reply
*req
)
1527 fprintf( stderr
, " handle=%04x", req
->handle
);
1530 static void dump_release_mutex_request( const struct release_mutex_request
*req
)
1532 fprintf( stderr
, " handle=%04x", req
->handle
);
1535 static void dump_release_mutex_reply( const struct release_mutex_reply
*req
)
1537 fprintf( stderr
, " prev_count=%08x", req
->prev_count
);
1540 static void dump_open_mutex_request( const struct open_mutex_request
*req
)
1542 fprintf( stderr
, " access=%08x", req
->access
);
1543 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1544 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1545 dump_varargs_unicode_str( ", name=", cur_size
);
1548 static void dump_open_mutex_reply( const struct open_mutex_reply
*req
)
1550 fprintf( stderr
, " handle=%04x", req
->handle
);
1553 static void dump_create_semaphore_request( const struct create_semaphore_request
*req
)
1555 fprintf( stderr
, " access=%08x", req
->access
);
1556 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1557 fprintf( stderr
, ", initial=%08x", req
->initial
);
1558 fprintf( stderr
, ", max=%08x", req
->max
);
1559 dump_varargs_object_attributes( ", objattr=", cur_size
);
1562 static void dump_create_semaphore_reply( const struct create_semaphore_reply
*req
)
1564 fprintf( stderr
, " handle=%04x", req
->handle
);
1567 static void dump_release_semaphore_request( const struct release_semaphore_request
*req
)
1569 fprintf( stderr
, " handle=%04x", req
->handle
);
1570 fprintf( stderr
, ", count=%08x", req
->count
);
1573 static void dump_release_semaphore_reply( const struct release_semaphore_reply
*req
)
1575 fprintf( stderr
, " prev_count=%08x", req
->prev_count
);
1578 static void dump_query_semaphore_request( const struct query_semaphore_request
*req
)
1580 fprintf( stderr
, " handle=%04x", req
->handle
);
1583 static void dump_query_semaphore_reply( const struct query_semaphore_reply
*req
)
1585 fprintf( stderr
, " current=%08x", req
->current
);
1586 fprintf( stderr
, ", max=%08x", req
->max
);
1589 static void dump_open_semaphore_request( const struct open_semaphore_request
*req
)
1591 fprintf( stderr
, " access=%08x", req
->access
);
1592 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1593 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1594 dump_varargs_unicode_str( ", name=", cur_size
);
1597 static void dump_open_semaphore_reply( const struct open_semaphore_reply
*req
)
1599 fprintf( stderr
, " handle=%04x", req
->handle
);
1602 static void dump_create_file_request( const struct create_file_request
*req
)
1604 fprintf( stderr
, " access=%08x", req
->access
);
1605 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1606 fprintf( stderr
, ", sharing=%08x", req
->sharing
);
1607 fprintf( stderr
, ", create=%d", req
->create
);
1608 fprintf( stderr
, ", options=%08x", req
->options
);
1609 fprintf( stderr
, ", attrs=%08x", req
->attrs
);
1610 dump_varargs_object_attributes( ", objattr=", cur_size
);
1611 dump_varargs_string( ", filename=", cur_size
);
1614 static void dump_create_file_reply( const struct create_file_reply
*req
)
1616 fprintf( stderr
, " handle=%04x", req
->handle
);
1619 static void dump_open_file_object_request( const struct open_file_object_request
*req
)
1621 fprintf( stderr
, " access=%08x", req
->access
);
1622 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1623 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1624 fprintf( stderr
, ", sharing=%08x", req
->sharing
);
1625 fprintf( stderr
, ", options=%08x", req
->options
);
1626 dump_varargs_unicode_str( ", filename=", cur_size
);
1629 static void dump_open_file_object_reply( const struct open_file_object_reply
*req
)
1631 fprintf( stderr
, " handle=%04x", req
->handle
);
1634 static void dump_alloc_file_handle_request( const struct alloc_file_handle_request
*req
)
1636 fprintf( stderr
, " access=%08x", req
->access
);
1637 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1638 fprintf( stderr
, ", fd=%d", req
->fd
);
1641 static void dump_alloc_file_handle_reply( const struct alloc_file_handle_reply
*req
)
1643 fprintf( stderr
, " handle=%04x", req
->handle
);
1646 static void dump_get_handle_unix_name_request( const struct get_handle_unix_name_request
*req
)
1648 fprintf( stderr
, " handle=%04x", req
->handle
);
1651 static void dump_get_handle_unix_name_reply( const struct get_handle_unix_name_reply
*req
)
1653 fprintf( stderr
, " name_len=%u", req
->name_len
);
1654 dump_varargs_string( ", name=", cur_size
);
1657 static void dump_get_handle_fd_request( const struct get_handle_fd_request
*req
)
1659 fprintf( stderr
, " handle=%04x", req
->handle
);
1662 static void dump_get_handle_fd_reply( const struct get_handle_fd_reply
*req
)
1664 fprintf( stderr
, " type=%d", req
->type
);
1665 fprintf( stderr
, ", cacheable=%d", req
->cacheable
);
1666 fprintf( stderr
, ", access=%08x", req
->access
);
1667 fprintf( stderr
, ", options=%08x", req
->options
);
1670 static void dump_flush_request( const struct flush_request
*req
)
1672 fprintf( stderr
, " blocking=%d", req
->blocking
);
1673 dump_async_data( ", async=", &req
->async
);
1676 static void dump_flush_reply( const struct flush_reply
*req
)
1678 fprintf( stderr
, " event=%04x", req
->event
);
1681 static void dump_lock_file_request( const struct lock_file_request
*req
)
1683 fprintf( stderr
, " handle=%04x", req
->handle
);
1684 dump_uint64( ", offset=", &req
->offset
);
1685 dump_uint64( ", count=", &req
->count
);
1686 fprintf( stderr
, ", shared=%d", req
->shared
);
1687 fprintf( stderr
, ", wait=%d", req
->wait
);
1690 static void dump_lock_file_reply( const struct lock_file_reply
*req
)
1692 fprintf( stderr
, " handle=%04x", req
->handle
);
1693 fprintf( stderr
, ", overlapped=%d", req
->overlapped
);
1696 static void dump_unlock_file_request( const struct unlock_file_request
*req
)
1698 fprintf( stderr
, " handle=%04x", req
->handle
);
1699 dump_uint64( ", offset=", &req
->offset
);
1700 dump_uint64( ", count=", &req
->count
);
1703 static void dump_create_socket_request( const struct create_socket_request
*req
)
1705 fprintf( stderr
, " access=%08x", req
->access
);
1706 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1707 fprintf( stderr
, ", family=%d", req
->family
);
1708 fprintf( stderr
, ", type=%d", req
->type
);
1709 fprintf( stderr
, ", protocol=%d", req
->protocol
);
1710 fprintf( stderr
, ", flags=%08x", req
->flags
);
1713 static void dump_create_socket_reply( const struct create_socket_reply
*req
)
1715 fprintf( stderr
, " handle=%04x", req
->handle
);
1718 static void dump_accept_socket_request( const struct accept_socket_request
*req
)
1720 fprintf( stderr
, " lhandle=%04x", req
->lhandle
);
1721 fprintf( stderr
, ", access=%08x", req
->access
);
1722 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1725 static void dump_accept_socket_reply( const struct accept_socket_reply
*req
)
1727 fprintf( stderr
, " handle=%04x", req
->handle
);
1730 static void dump_accept_into_socket_request( const struct accept_into_socket_request
*req
)
1732 fprintf( stderr
, " lhandle=%04x", req
->lhandle
);
1733 fprintf( stderr
, ", ahandle=%04x", req
->ahandle
);
1736 static void dump_set_socket_event_request( const struct set_socket_event_request
*req
)
1738 fprintf( stderr
, " handle=%04x", req
->handle
);
1739 fprintf( stderr
, ", mask=%08x", req
->mask
);
1740 fprintf( stderr
, ", event=%04x", req
->event
);
1741 fprintf( stderr
, ", window=%08x", req
->window
);
1742 fprintf( stderr
, ", msg=%08x", req
->msg
);
1745 static void dump_get_socket_event_request( const struct get_socket_event_request
*req
)
1747 fprintf( stderr
, " handle=%04x", req
->handle
);
1748 fprintf( stderr
, ", service=%d", req
->service
);
1749 fprintf( stderr
, ", c_event=%04x", req
->c_event
);
1752 static void dump_get_socket_event_reply( const struct get_socket_event_reply
*req
)
1754 fprintf( stderr
, " mask=%08x", req
->mask
);
1755 fprintf( stderr
, ", pmask=%08x", req
->pmask
);
1756 fprintf( stderr
, ", state=%08x", req
->state
);
1757 dump_varargs_ints( ", errors=", cur_size
);
1760 static void dump_get_socket_info_request( const struct get_socket_info_request
*req
)
1762 fprintf( stderr
, " handle=%04x", req
->handle
);
1765 static void dump_get_socket_info_reply( const struct get_socket_info_reply
*req
)
1767 fprintf( stderr
, " family=%d", req
->family
);
1768 fprintf( stderr
, ", type=%d", req
->type
);
1769 fprintf( stderr
, ", protocol=%d", req
->protocol
);
1772 static void dump_enable_socket_event_request( const struct enable_socket_event_request
*req
)
1774 fprintf( stderr
, " handle=%04x", req
->handle
);
1775 fprintf( stderr
, ", mask=%08x", req
->mask
);
1776 fprintf( stderr
, ", sstate=%08x", req
->sstate
);
1777 fprintf( stderr
, ", cstate=%08x", req
->cstate
);
1780 static void dump_set_socket_deferred_request( const struct set_socket_deferred_request
*req
)
1782 fprintf( stderr
, " handle=%04x", req
->handle
);
1783 fprintf( stderr
, ", deferred=%04x", req
->deferred
);
1786 static void dump_alloc_console_request( const struct alloc_console_request
*req
)
1788 fprintf( stderr
, " access=%08x", req
->access
);
1789 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1790 fprintf( stderr
, ", pid=%04x", req
->pid
);
1791 fprintf( stderr
, ", input_fd=%d", req
->input_fd
);
1794 static void dump_alloc_console_reply( const struct alloc_console_reply
*req
)
1796 fprintf( stderr
, " handle_in=%04x", req
->handle_in
);
1797 fprintf( stderr
, ", event=%04x", req
->event
);
1800 static void dump_free_console_request( const struct free_console_request
*req
)
1804 static void dump_get_console_renderer_events_request( const struct get_console_renderer_events_request
*req
)
1806 fprintf( stderr
, " handle=%04x", req
->handle
);
1809 static void dump_get_console_renderer_events_reply( const struct get_console_renderer_events_reply
*req
)
1811 dump_varargs_bytes( " data=", cur_size
);
1814 static void dump_open_console_request( const struct open_console_request
*req
)
1816 fprintf( stderr
, " from=%04x", req
->from
);
1817 fprintf( stderr
, ", access=%08x", req
->access
);
1818 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1819 fprintf( stderr
, ", share=%d", req
->share
);
1822 static void dump_open_console_reply( const struct open_console_reply
*req
)
1824 fprintf( stderr
, " handle=%04x", req
->handle
);
1827 static void dump_get_console_wait_event_request( const struct get_console_wait_event_request
*req
)
1831 static void dump_get_console_wait_event_reply( const struct get_console_wait_event_reply
*req
)
1833 fprintf( stderr
, " handle=%04x", req
->handle
);
1836 static void dump_get_console_mode_request( const struct get_console_mode_request
*req
)
1838 fprintf( stderr
, " handle=%04x", req
->handle
);
1841 static void dump_get_console_mode_reply( const struct get_console_mode_reply
*req
)
1843 fprintf( stderr
, " mode=%d", req
->mode
);
1846 static void dump_set_console_mode_request( const struct set_console_mode_request
*req
)
1848 fprintf( stderr
, " handle=%04x", req
->handle
);
1849 fprintf( stderr
, ", mode=%d", req
->mode
);
1852 static void dump_set_console_input_info_request( const struct set_console_input_info_request
*req
)
1854 fprintf( stderr
, " handle=%04x", req
->handle
);
1855 fprintf( stderr
, ", mask=%d", req
->mask
);
1856 fprintf( stderr
, ", active_sb=%04x", req
->active_sb
);
1857 fprintf( stderr
, ", history_mode=%d", req
->history_mode
);
1858 fprintf( stderr
, ", history_size=%d", req
->history_size
);
1859 fprintf( stderr
, ", edition_mode=%d", req
->edition_mode
);
1860 fprintf( stderr
, ", input_cp=%d", req
->input_cp
);
1861 fprintf( stderr
, ", output_cp=%d", req
->output_cp
);
1862 fprintf( stderr
, ", win=%08x", req
->win
);
1863 dump_varargs_unicode_str( ", title=", cur_size
);
1866 static void dump_get_console_input_info_request( const struct get_console_input_info_request
*req
)
1868 fprintf( stderr
, " handle=%04x", req
->handle
);
1871 static void dump_get_console_input_info_reply( const struct get_console_input_info_reply
*req
)
1873 fprintf( stderr
, " history_mode=%d", req
->history_mode
);
1874 fprintf( stderr
, ", history_size=%d", req
->history_size
);
1875 fprintf( stderr
, ", history_index=%d", req
->history_index
);
1876 fprintf( stderr
, ", edition_mode=%d", req
->edition_mode
);
1877 fprintf( stderr
, ", input_cp=%d", req
->input_cp
);
1878 fprintf( stderr
, ", output_cp=%d", req
->output_cp
);
1879 fprintf( stderr
, ", win=%08x", req
->win
);
1880 dump_varargs_unicode_str( ", title=", cur_size
);
1883 static void dump_append_console_input_history_request( const struct append_console_input_history_request
*req
)
1885 fprintf( stderr
, " handle=%04x", req
->handle
);
1886 dump_varargs_unicode_str( ", line=", cur_size
);
1889 static void dump_get_console_input_history_request( const struct get_console_input_history_request
*req
)
1891 fprintf( stderr
, " handle=%04x", req
->handle
);
1892 fprintf( stderr
, ", index=%d", req
->index
);
1895 static void dump_get_console_input_history_reply( const struct get_console_input_history_reply
*req
)
1897 fprintf( stderr
, " total=%d", req
->total
);
1898 dump_varargs_unicode_str( ", line=", cur_size
);
1901 static void dump_create_console_output_request( const struct create_console_output_request
*req
)
1903 fprintf( stderr
, " handle_in=%04x", req
->handle_in
);
1904 fprintf( stderr
, ", access=%08x", req
->access
);
1905 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1906 fprintf( stderr
, ", share=%08x", req
->share
);
1907 fprintf( stderr
, ", fd=%d", req
->fd
);
1910 static void dump_create_console_output_reply( const struct create_console_output_reply
*req
)
1912 fprintf( stderr
, " handle_out=%04x", req
->handle_out
);
1915 static void dump_set_console_output_info_request( const struct set_console_output_info_request
*req
)
1917 fprintf( stderr
, " handle=%04x", req
->handle
);
1918 fprintf( stderr
, ", mask=%d", req
->mask
);
1919 fprintf( stderr
, ", cursor_size=%d", req
->cursor_size
);
1920 fprintf( stderr
, ", cursor_visible=%d", req
->cursor_visible
);
1921 fprintf( stderr
, ", cursor_x=%d", req
->cursor_x
);
1922 fprintf( stderr
, ", cursor_y=%d", req
->cursor_y
);
1923 fprintf( stderr
, ", width=%d", req
->width
);
1924 fprintf( stderr
, ", height=%d", req
->height
);
1925 fprintf( stderr
, ", attr=%d", req
->attr
);
1926 fprintf( stderr
, ", win_left=%d", req
->win_left
);
1927 fprintf( stderr
, ", win_top=%d", req
->win_top
);
1928 fprintf( stderr
, ", win_right=%d", req
->win_right
);
1929 fprintf( stderr
, ", win_bottom=%d", req
->win_bottom
);
1930 fprintf( stderr
, ", max_width=%d", req
->max_width
);
1931 fprintf( stderr
, ", max_height=%d", req
->max_height
);
1934 static void dump_get_console_output_info_request( const struct get_console_output_info_request
*req
)
1936 fprintf( stderr
, " handle=%04x", req
->handle
);
1939 static void dump_get_console_output_info_reply( const struct get_console_output_info_reply
*req
)
1941 fprintf( stderr
, " cursor_size=%d", req
->cursor_size
);
1942 fprintf( stderr
, ", cursor_visible=%d", req
->cursor_visible
);
1943 fprintf( stderr
, ", cursor_x=%d", req
->cursor_x
);
1944 fprintf( stderr
, ", cursor_y=%d", req
->cursor_y
);
1945 fprintf( stderr
, ", width=%d", req
->width
);
1946 fprintf( stderr
, ", height=%d", req
->height
);
1947 fprintf( stderr
, ", attr=%d", req
->attr
);
1948 fprintf( stderr
, ", win_left=%d", req
->win_left
);
1949 fprintf( stderr
, ", win_top=%d", req
->win_top
);
1950 fprintf( stderr
, ", win_right=%d", req
->win_right
);
1951 fprintf( stderr
, ", win_bottom=%d", req
->win_bottom
);
1952 fprintf( stderr
, ", max_width=%d", req
->max_width
);
1953 fprintf( stderr
, ", max_height=%d", req
->max_height
);
1956 static void dump_write_console_input_request( const struct write_console_input_request
*req
)
1958 fprintf( stderr
, " handle=%04x", req
->handle
);
1959 dump_varargs_input_records( ", rec=", cur_size
);
1962 static void dump_write_console_input_reply( const struct write_console_input_reply
*req
)
1964 fprintf( stderr
, " written=%d", req
->written
);
1967 static void dump_read_console_input_request( const struct read_console_input_request
*req
)
1969 fprintf( stderr
, " handle=%04x", req
->handle
);
1970 fprintf( stderr
, ", flush=%d", req
->flush
);
1973 static void dump_read_console_input_reply( const struct read_console_input_reply
*req
)
1975 fprintf( stderr
, " read=%d", req
->read
);
1976 dump_varargs_input_records( ", rec=", cur_size
);
1979 static void dump_write_console_output_request( const struct write_console_output_request
*req
)
1981 fprintf( stderr
, " handle=%04x", req
->handle
);
1982 fprintf( stderr
, ", x=%d", req
->x
);
1983 fprintf( stderr
, ", y=%d", req
->y
);
1984 fprintf( stderr
, ", mode=%d", req
->mode
);
1985 fprintf( stderr
, ", wrap=%d", req
->wrap
);
1986 dump_varargs_bytes( ", data=", cur_size
);
1989 static void dump_write_console_output_reply( const struct write_console_output_reply
*req
)
1991 fprintf( stderr
, " written=%d", req
->written
);
1992 fprintf( stderr
, ", width=%d", req
->width
);
1993 fprintf( stderr
, ", height=%d", req
->height
);
1996 static void dump_fill_console_output_request( const struct fill_console_output_request
*req
)
1998 fprintf( stderr
, " handle=%04x", req
->handle
);
1999 fprintf( stderr
, ", x=%d", req
->x
);
2000 fprintf( stderr
, ", y=%d", req
->y
);
2001 fprintf( stderr
, ", mode=%d", req
->mode
);
2002 fprintf( stderr
, ", count=%d", req
->count
);
2003 fprintf( stderr
, ", wrap=%d", req
->wrap
);
2004 dump_char_info( ", data=", &req
->data
);
2007 static void dump_fill_console_output_reply( const struct fill_console_output_reply
*req
)
2009 fprintf( stderr
, " written=%d", req
->written
);
2012 static void dump_read_console_output_request( const struct read_console_output_request
*req
)
2014 fprintf( stderr
, " handle=%04x", req
->handle
);
2015 fprintf( stderr
, ", x=%d", req
->x
);
2016 fprintf( stderr
, ", y=%d", req
->y
);
2017 fprintf( stderr
, ", mode=%d", req
->mode
);
2018 fprintf( stderr
, ", wrap=%d", req
->wrap
);
2021 static void dump_read_console_output_reply( const struct read_console_output_reply
*req
)
2023 fprintf( stderr
, " width=%d", req
->width
);
2024 fprintf( stderr
, ", height=%d", req
->height
);
2025 dump_varargs_bytes( ", data=", cur_size
);
2028 static void dump_move_console_output_request( const struct move_console_output_request
*req
)
2030 fprintf( stderr
, " handle=%04x", req
->handle
);
2031 fprintf( stderr
, ", x_src=%d", req
->x_src
);
2032 fprintf( stderr
, ", y_src=%d", req
->y_src
);
2033 fprintf( stderr
, ", x_dst=%d", req
->x_dst
);
2034 fprintf( stderr
, ", y_dst=%d", req
->y_dst
);
2035 fprintf( stderr
, ", w=%d", req
->w
);
2036 fprintf( stderr
, ", h=%d", req
->h
);
2039 static void dump_send_console_signal_request( const struct send_console_signal_request
*req
)
2041 fprintf( stderr
, " signal=%d", req
->signal
);
2042 fprintf( stderr
, ", group_id=%04x", req
->group_id
);
2045 static void dump_read_directory_changes_request( const struct read_directory_changes_request
*req
)
2047 fprintf( stderr
, " filter=%08x", req
->filter
);
2048 fprintf( stderr
, ", subtree=%d", req
->subtree
);
2049 fprintf( stderr
, ", want_data=%d", req
->want_data
);
2050 dump_async_data( ", async=", &req
->async
);
2053 static void dump_read_change_request( const struct read_change_request
*req
)
2055 fprintf( stderr
, " handle=%04x", req
->handle
);
2058 static void dump_read_change_reply( const struct read_change_reply
*req
)
2060 dump_varargs_filesystem_event( " events=", cur_size
);
2063 static void dump_create_mapping_request( const struct create_mapping_request
*req
)
2065 fprintf( stderr
, " access=%08x", req
->access
);
2066 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2067 fprintf( stderr
, ", protect=%08x", req
->protect
);
2068 dump_uint64( ", size=", &req
->size
);
2069 fprintf( stderr
, ", file_handle=%04x", req
->file_handle
);
2070 dump_varargs_object_attributes( ", objattr=", cur_size
);
2073 static void dump_create_mapping_reply( const struct create_mapping_reply
*req
)
2075 fprintf( stderr
, " handle=%04x", req
->handle
);
2078 static void dump_open_mapping_request( const struct open_mapping_request
*req
)
2080 fprintf( stderr
, " access=%08x", req
->access
);
2081 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2082 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
2083 dump_varargs_unicode_str( ", name=", cur_size
);
2086 static void dump_open_mapping_reply( const struct open_mapping_reply
*req
)
2088 fprintf( stderr
, " handle=%04x", req
->handle
);
2091 static void dump_get_mapping_info_request( const struct get_mapping_info_request
*req
)
2093 fprintf( stderr
, " handle=%04x", req
->handle
);
2094 fprintf( stderr
, ", access=%08x", req
->access
);
2097 static void dump_get_mapping_info_reply( const struct get_mapping_info_reply
*req
)
2099 dump_uint64( " size=", &req
->size
);
2100 fprintf( stderr
, ", protect=%d", req
->protect
);
2101 fprintf( stderr
, ", header_size=%d", req
->header_size
);
2102 dump_uint64( ", base=", &req
->base
);
2103 fprintf( stderr
, ", mapping=%04x", req
->mapping
);
2104 fprintf( stderr
, ", shared_file=%04x", req
->shared_file
);
2107 static void dump_get_mapping_committed_range_request( const struct get_mapping_committed_range_request
*req
)
2109 fprintf( stderr
, " handle=%04x", req
->handle
);
2110 dump_uint64( ", offset=", &req
->offset
);
2113 static void dump_get_mapping_committed_range_reply( const struct get_mapping_committed_range_reply
*req
)
2115 dump_uint64( " size=", &req
->size
);
2116 fprintf( stderr
, ", committed=%d", req
->committed
);
2119 static void dump_add_mapping_committed_range_request( const struct add_mapping_committed_range_request
*req
)
2121 fprintf( stderr
, " handle=%04x", req
->handle
);
2122 dump_uint64( ", offset=", &req
->offset
);
2123 dump_uint64( ", size=", &req
->size
);
2126 static void dump_create_snapshot_request( const struct create_snapshot_request
*req
)
2128 fprintf( stderr
, " attributes=%08x", req
->attributes
);
2129 fprintf( stderr
, ", flags=%08x", req
->flags
);
2132 static void dump_create_snapshot_reply( const struct create_snapshot_reply
*req
)
2134 fprintf( stderr
, " handle=%04x", req
->handle
);
2137 static void dump_next_process_request( const struct next_process_request
*req
)
2139 fprintf( stderr
, " handle=%04x", req
->handle
);
2140 fprintf( stderr
, ", reset=%d", req
->reset
);
2143 static void dump_next_process_reply( const struct next_process_reply
*req
)
2145 fprintf( stderr
, " count=%d", req
->count
);
2146 fprintf( stderr
, ", pid=%04x", req
->pid
);
2147 fprintf( stderr
, ", ppid=%04x", req
->ppid
);
2148 fprintf( stderr
, ", threads=%d", req
->threads
);
2149 fprintf( stderr
, ", priority=%d", req
->priority
);
2150 fprintf( stderr
, ", handles=%d", req
->handles
);
2151 fprintf( stderr
, ", unix_pid=%d", req
->unix_pid
);
2152 dump_varargs_unicode_str( ", filename=", cur_size
);
2155 static void dump_next_thread_request( const struct next_thread_request
*req
)
2157 fprintf( stderr
, " handle=%04x", req
->handle
);
2158 fprintf( stderr
, ", reset=%d", req
->reset
);
2161 static void dump_next_thread_reply( const struct next_thread_reply
*req
)
2163 fprintf( stderr
, " count=%d", req
->count
);
2164 fprintf( stderr
, ", pid=%04x", req
->pid
);
2165 fprintf( stderr
, ", tid=%04x", req
->tid
);
2166 fprintf( stderr
, ", base_pri=%d", req
->base_pri
);
2167 fprintf( stderr
, ", delta_pri=%d", req
->delta_pri
);
2170 static void dump_wait_debug_event_request( const struct wait_debug_event_request
*req
)
2172 fprintf( stderr
, " get_handle=%d", req
->get_handle
);
2175 static void dump_wait_debug_event_reply( const struct wait_debug_event_reply
*req
)
2177 fprintf( stderr
, " pid=%04x", req
->pid
);
2178 fprintf( stderr
, ", tid=%04x", req
->tid
);
2179 fprintf( stderr
, ", wait=%04x", req
->wait
);
2180 dump_varargs_debug_event( ", event=", cur_size
);
2183 static void dump_queue_exception_event_request( const struct queue_exception_event_request
*req
)
2185 fprintf( stderr
, " first=%d", req
->first
);
2186 fprintf( stderr
, ", code=%08x", req
->code
);
2187 fprintf( stderr
, ", flags=%08x", req
->flags
);
2188 dump_uint64( ", record=", &req
->record
);
2189 dump_uint64( ", address=", &req
->address
);
2190 fprintf( stderr
, ", len=%u", req
->len
);
2191 dump_varargs_uints64( ", params=", min(cur_size
,req
->len
) );
2192 dump_varargs_context( ", context=", cur_size
);
2195 static void dump_queue_exception_event_reply( const struct queue_exception_event_reply
*req
)
2197 fprintf( stderr
, " handle=%04x", req
->handle
);
2200 static void dump_get_exception_status_request( const struct get_exception_status_request
*req
)
2202 fprintf( stderr
, " handle=%04x", req
->handle
);
2205 static void dump_get_exception_status_reply( const struct get_exception_status_reply
*req
)
2207 dump_varargs_context( " context=", cur_size
);
2210 static void dump_continue_debug_event_request( const struct continue_debug_event_request
*req
)
2212 fprintf( stderr
, " pid=%04x", req
->pid
);
2213 fprintf( stderr
, ", tid=%04x", req
->tid
);
2214 fprintf( stderr
, ", status=%d", req
->status
);
2217 static void dump_debug_process_request( const struct debug_process_request
*req
)
2219 fprintf( stderr
, " pid=%04x", req
->pid
);
2220 fprintf( stderr
, ", attach=%d", req
->attach
);
2223 static void dump_debug_break_request( const struct debug_break_request
*req
)
2225 fprintf( stderr
, " handle=%04x", req
->handle
);
2228 static void dump_debug_break_reply( const struct debug_break_reply
*req
)
2230 fprintf( stderr
, " self=%d", req
->self
);
2233 static void dump_set_debugger_kill_on_exit_request( const struct set_debugger_kill_on_exit_request
*req
)
2235 fprintf( stderr
, " kill_on_exit=%d", req
->kill_on_exit
);
2238 static void dump_read_process_memory_request( const struct read_process_memory_request
*req
)
2240 fprintf( stderr
, " handle=%04x", req
->handle
);
2241 dump_uint64( ", addr=", &req
->addr
);
2244 static void dump_read_process_memory_reply( const struct read_process_memory_reply
*req
)
2246 dump_varargs_bytes( " data=", cur_size
);
2249 static void dump_write_process_memory_request( const struct write_process_memory_request
*req
)
2251 fprintf( stderr
, " handle=%04x", req
->handle
);
2252 dump_uint64( ", addr=", &req
->addr
);
2253 dump_varargs_bytes( ", data=", cur_size
);
2256 static void dump_create_key_request( const struct create_key_request
*req
)
2258 fprintf( stderr
, " parent=%04x", req
->parent
);
2259 fprintf( stderr
, ", access=%08x", req
->access
);
2260 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2261 fprintf( stderr
, ", options=%08x", req
->options
);
2262 fprintf( stderr
, ", namelen=%u", req
->namelen
);
2263 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->namelen
) );
2264 dump_varargs_unicode_str( ", class=", cur_size
);
2267 static void dump_create_key_reply( const struct create_key_reply
*req
)
2269 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2270 fprintf( stderr
, ", created=%d", req
->created
);
2273 static void dump_open_key_request( const struct open_key_request
*req
)
2275 fprintf( stderr
, " parent=%04x", req
->parent
);
2276 fprintf( stderr
, ", access=%08x", req
->access
);
2277 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2278 dump_varargs_unicode_str( ", name=", cur_size
);
2281 static void dump_open_key_reply( const struct open_key_reply
*req
)
2283 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2286 static void dump_delete_key_request( const struct delete_key_request
*req
)
2288 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2291 static void dump_flush_key_request( const struct flush_key_request
*req
)
2293 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2296 static void dump_enum_key_request( const struct enum_key_request
*req
)
2298 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2299 fprintf( stderr
, ", index=%d", req
->index
);
2300 fprintf( stderr
, ", info_class=%d", req
->info_class
);
2303 static void dump_enum_key_reply( const struct enum_key_reply
*req
)
2305 fprintf( stderr
, " subkeys=%d", req
->subkeys
);
2306 fprintf( stderr
, ", max_subkey=%d", req
->max_subkey
);
2307 fprintf( stderr
, ", max_class=%d", req
->max_class
);
2308 fprintf( stderr
, ", values=%d", req
->values
);
2309 fprintf( stderr
, ", max_value=%d", req
->max_value
);
2310 fprintf( stderr
, ", max_data=%d", req
->max_data
);
2311 dump_timeout( ", modif=", &req
->modif
);
2312 fprintf( stderr
, ", total=%u", req
->total
);
2313 fprintf( stderr
, ", namelen=%u", req
->namelen
);
2314 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->namelen
) );
2315 dump_varargs_unicode_str( ", class=", cur_size
);
2318 static void dump_set_key_value_request( const struct set_key_value_request
*req
)
2320 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2321 fprintf( stderr
, ", type=%d", req
->type
);
2322 fprintf( stderr
, ", namelen=%u", req
->namelen
);
2323 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->namelen
) );
2324 dump_varargs_bytes( ", data=", cur_size
);
2327 static void dump_get_key_value_request( const struct get_key_value_request
*req
)
2329 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2330 dump_varargs_unicode_str( ", name=", cur_size
);
2333 static void dump_get_key_value_reply( const struct get_key_value_reply
*req
)
2335 fprintf( stderr
, " type=%d", req
->type
);
2336 fprintf( stderr
, ", total=%u", req
->total
);
2337 dump_varargs_bytes( ", data=", cur_size
);
2340 static void dump_enum_key_value_request( const struct enum_key_value_request
*req
)
2342 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2343 fprintf( stderr
, ", index=%d", req
->index
);
2344 fprintf( stderr
, ", info_class=%d", req
->info_class
);
2347 static void dump_enum_key_value_reply( const struct enum_key_value_reply
*req
)
2349 fprintf( stderr
, " type=%d", req
->type
);
2350 fprintf( stderr
, ", total=%u", req
->total
);
2351 fprintf( stderr
, ", namelen=%u", req
->namelen
);
2352 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->namelen
) );
2353 dump_varargs_bytes( ", data=", cur_size
);
2356 static void dump_delete_key_value_request( const struct delete_key_value_request
*req
)
2358 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2359 dump_varargs_unicode_str( ", name=", cur_size
);
2362 static void dump_load_registry_request( const struct load_registry_request
*req
)
2364 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2365 fprintf( stderr
, ", file=%04x", req
->file
);
2366 dump_varargs_unicode_str( ", name=", cur_size
);
2369 static void dump_unload_registry_request( const struct unload_registry_request
*req
)
2371 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2374 static void dump_save_registry_request( const struct save_registry_request
*req
)
2376 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2377 fprintf( stderr
, ", file=%04x", req
->file
);
2380 static void dump_set_registry_notification_request( const struct set_registry_notification_request
*req
)
2382 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2383 fprintf( stderr
, ", event=%04x", req
->event
);
2384 fprintf( stderr
, ", subtree=%d", req
->subtree
);
2385 fprintf( stderr
, ", filter=%08x", req
->filter
);
2388 static void dump_create_timer_request( const struct create_timer_request
*req
)
2390 fprintf( stderr
, " access=%08x", req
->access
);
2391 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2392 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
2393 fprintf( stderr
, ", manual=%d", req
->manual
);
2394 dump_varargs_unicode_str( ", name=", cur_size
);
2397 static void dump_create_timer_reply( const struct create_timer_reply
*req
)
2399 fprintf( stderr
, " handle=%04x", req
->handle
);
2402 static void dump_open_timer_request( const struct open_timer_request
*req
)
2404 fprintf( stderr
, " access=%08x", req
->access
);
2405 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2406 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
2407 dump_varargs_unicode_str( ", name=", cur_size
);
2410 static void dump_open_timer_reply( const struct open_timer_reply
*req
)
2412 fprintf( stderr
, " handle=%04x", req
->handle
);
2415 static void dump_set_timer_request( const struct set_timer_request
*req
)
2417 fprintf( stderr
, " handle=%04x", req
->handle
);
2418 dump_timeout( ", expire=", &req
->expire
);
2419 dump_uint64( ", callback=", &req
->callback
);
2420 dump_uint64( ", arg=", &req
->arg
);
2421 fprintf( stderr
, ", period=%d", req
->period
);
2424 static void dump_set_timer_reply( const struct set_timer_reply
*req
)
2426 fprintf( stderr
, " signaled=%d", req
->signaled
);
2429 static void dump_cancel_timer_request( const struct cancel_timer_request
*req
)
2431 fprintf( stderr
, " handle=%04x", req
->handle
);
2434 static void dump_cancel_timer_reply( const struct cancel_timer_reply
*req
)
2436 fprintf( stderr
, " signaled=%d", req
->signaled
);
2439 static void dump_get_timer_info_request( const struct get_timer_info_request
*req
)
2441 fprintf( stderr
, " handle=%04x", req
->handle
);
2444 static void dump_get_timer_info_reply( const struct get_timer_info_reply
*req
)
2446 dump_timeout( " when=", &req
->when
);
2447 fprintf( stderr
, ", signaled=%d", req
->signaled
);
2450 static void dump_get_thread_context_request( const struct get_thread_context_request
*req
)
2452 fprintf( stderr
, " handle=%04x", req
->handle
);
2453 fprintf( stderr
, ", flags=%08x", req
->flags
);
2454 fprintf( stderr
, ", suspend=%d", req
->suspend
);
2457 static void dump_get_thread_context_reply( const struct get_thread_context_reply
*req
)
2459 fprintf( stderr
, " self=%d", req
->self
);
2460 dump_varargs_context( ", context=", cur_size
);
2463 static void dump_set_thread_context_request( const struct set_thread_context_request
*req
)
2465 fprintf( stderr
, " handle=%04x", req
->handle
);
2466 fprintf( stderr
, ", suspend=%d", req
->suspend
);
2467 dump_varargs_context( ", context=", cur_size
);
2470 static void dump_set_thread_context_reply( const struct set_thread_context_reply
*req
)
2472 fprintf( stderr
, " self=%d", req
->self
);
2475 static void dump_get_selector_entry_request( const struct get_selector_entry_request
*req
)
2477 fprintf( stderr
, " handle=%04x", req
->handle
);
2478 fprintf( stderr
, ", entry=%d", req
->entry
);
2481 static void dump_get_selector_entry_reply( const struct get_selector_entry_reply
*req
)
2483 fprintf( stderr
, " base=%08x", req
->base
);
2484 fprintf( stderr
, ", limit=%08x", req
->limit
);
2485 fprintf( stderr
, ", flags=%02x", req
->flags
);
2488 static void dump_add_atom_request( const struct add_atom_request
*req
)
2490 fprintf( stderr
, " table=%04x", req
->table
);
2491 dump_varargs_unicode_str( ", name=", cur_size
);
2494 static void dump_add_atom_reply( const struct add_atom_reply
*req
)
2496 fprintf( stderr
, " atom=%04x", req
->atom
);
2499 static void dump_delete_atom_request( const struct delete_atom_request
*req
)
2501 fprintf( stderr
, " table=%04x", req
->table
);
2502 fprintf( stderr
, ", atom=%04x", req
->atom
);
2505 static void dump_find_atom_request( const struct find_atom_request
*req
)
2507 fprintf( stderr
, " table=%04x", req
->table
);
2508 dump_varargs_unicode_str( ", name=", cur_size
);
2511 static void dump_find_atom_reply( const struct find_atom_reply
*req
)
2513 fprintf( stderr
, " atom=%04x", req
->atom
);
2516 static void dump_get_atom_information_request( const struct get_atom_information_request
*req
)
2518 fprintf( stderr
, " table=%04x", req
->table
);
2519 fprintf( stderr
, ", atom=%04x", req
->atom
);
2522 static void dump_get_atom_information_reply( const struct get_atom_information_reply
*req
)
2524 fprintf( stderr
, " count=%d", req
->count
);
2525 fprintf( stderr
, ", pinned=%d", req
->pinned
);
2526 fprintf( stderr
, ", total=%u", req
->total
);
2527 dump_varargs_unicode_str( ", name=", cur_size
);
2530 static void dump_set_atom_information_request( const struct set_atom_information_request
*req
)
2532 fprintf( stderr
, " table=%04x", req
->table
);
2533 fprintf( stderr
, ", atom=%04x", req
->atom
);
2534 fprintf( stderr
, ", pinned=%d", req
->pinned
);
2537 static void dump_empty_atom_table_request( const struct empty_atom_table_request
*req
)
2539 fprintf( stderr
, " table=%04x", req
->table
);
2540 fprintf( stderr
, ", if_pinned=%d", req
->if_pinned
);
2543 static void dump_init_atom_table_request( const struct init_atom_table_request
*req
)
2545 fprintf( stderr
, " entries=%d", req
->entries
);
2548 static void dump_init_atom_table_reply( const struct init_atom_table_reply
*req
)
2550 fprintf( stderr
, " table=%04x", req
->table
);
2553 static void dump_get_msg_queue_request( const struct get_msg_queue_request
*req
)
2557 static void dump_get_msg_queue_reply( const struct get_msg_queue_reply
*req
)
2559 fprintf( stderr
, " handle=%04x", req
->handle
);
2562 static void dump_set_queue_fd_request( const struct set_queue_fd_request
*req
)
2564 fprintf( stderr
, " handle=%04x", req
->handle
);
2567 static void dump_set_queue_mask_request( const struct set_queue_mask_request
*req
)
2569 fprintf( stderr
, " wake_mask=%08x", req
->wake_mask
);
2570 fprintf( stderr
, ", changed_mask=%08x", req
->changed_mask
);
2571 fprintf( stderr
, ", skip_wait=%d", req
->skip_wait
);
2574 static void dump_set_queue_mask_reply( const struct set_queue_mask_reply
*req
)
2576 fprintf( stderr
, " wake_bits=%08x", req
->wake_bits
);
2577 fprintf( stderr
, ", changed_bits=%08x", req
->changed_bits
);
2580 static void dump_get_queue_status_request( const struct get_queue_status_request
*req
)
2582 fprintf( stderr
, " clear_bits=%08x", req
->clear_bits
);
2585 static void dump_get_queue_status_reply( const struct get_queue_status_reply
*req
)
2587 fprintf( stderr
, " wake_bits=%08x", req
->wake_bits
);
2588 fprintf( stderr
, ", changed_bits=%08x", req
->changed_bits
);
2591 static void dump_get_process_idle_event_request( const struct get_process_idle_event_request
*req
)
2593 fprintf( stderr
, " handle=%04x", req
->handle
);
2596 static void dump_get_process_idle_event_reply( const struct get_process_idle_event_reply
*req
)
2598 fprintf( stderr
, " event=%04x", req
->event
);
2601 static void dump_send_message_request( const struct send_message_request
*req
)
2603 fprintf( stderr
, " id=%04x", req
->id
);
2604 fprintf( stderr
, ", type=%d", req
->type
);
2605 fprintf( stderr
, ", flags=%d", req
->flags
);
2606 fprintf( stderr
, ", win=%08x", req
->win
);
2607 fprintf( stderr
, ", msg=%08x", req
->msg
);
2608 dump_uint64( ", wparam=", &req
->wparam
);
2609 dump_uint64( ", lparam=", &req
->lparam
);
2610 dump_timeout( ", timeout=", &req
->timeout
);
2611 dump_varargs_message_data( ", data=", cur_size
);
2614 static void dump_post_quit_message_request( const struct post_quit_message_request
*req
)
2616 fprintf( stderr
, " exit_code=%d", req
->exit_code
);
2619 static void dump_send_hardware_message_request( const struct send_hardware_message_request
*req
)
2621 fprintf( stderr
, " win=%08x", req
->win
);
2622 dump_hw_input( ", input=", &req
->input
);
2623 fprintf( stderr
, ", flags=%08x", req
->flags
);
2626 static void dump_send_hardware_message_reply( const struct send_hardware_message_reply
*req
)
2628 fprintf( stderr
, " wait=%d", req
->wait
);
2629 fprintf( stderr
, ", prev_x=%d", req
->prev_x
);
2630 fprintf( stderr
, ", prev_y=%d", req
->prev_y
);
2631 fprintf( stderr
, ", new_x=%d", req
->new_x
);
2632 fprintf( stderr
, ", new_y=%d", req
->new_y
);
2633 dump_varargs_bytes( ", keystate=", cur_size
);
2636 static void dump_get_message_request( const struct get_message_request
*req
)
2638 fprintf( stderr
, " flags=%08x", req
->flags
);
2639 fprintf( stderr
, ", get_win=%08x", req
->get_win
);
2640 fprintf( stderr
, ", get_first=%08x", req
->get_first
);
2641 fprintf( stderr
, ", get_last=%08x", req
->get_last
);
2642 fprintf( stderr
, ", hw_id=%08x", req
->hw_id
);
2643 fprintf( stderr
, ", wake_mask=%08x", req
->wake_mask
);
2644 fprintf( stderr
, ", changed_mask=%08x", req
->changed_mask
);
2647 static void dump_get_message_reply( const struct get_message_reply
*req
)
2649 fprintf( stderr
, " win=%08x", req
->win
);
2650 fprintf( stderr
, ", msg=%08x", req
->msg
);
2651 dump_uint64( ", wparam=", &req
->wparam
);
2652 dump_uint64( ", lparam=", &req
->lparam
);
2653 fprintf( stderr
, ", type=%d", req
->type
);
2654 fprintf( stderr
, ", x=%d", req
->x
);
2655 fprintf( stderr
, ", y=%d", req
->y
);
2656 fprintf( stderr
, ", time=%08x", req
->time
);
2657 fprintf( stderr
, ", active_hooks=%08x", req
->active_hooks
);
2658 fprintf( stderr
, ", total=%u", req
->total
);
2659 dump_varargs_message_data( ", data=", cur_size
);
2662 static void dump_reply_message_request( const struct reply_message_request
*req
)
2664 fprintf( stderr
, " remove=%d", req
->remove
);
2665 dump_uint64( ", result=", &req
->result
);
2666 dump_varargs_bytes( ", data=", cur_size
);
2669 static void dump_accept_hardware_message_request( const struct accept_hardware_message_request
*req
)
2671 fprintf( stderr
, " hw_id=%08x", req
->hw_id
);
2672 fprintf( stderr
, ", remove=%d", req
->remove
);
2675 static void dump_get_message_reply_request( const struct get_message_reply_request
*req
)
2677 fprintf( stderr
, " cancel=%d", req
->cancel
);
2680 static void dump_get_message_reply_reply( const struct get_message_reply_reply
*req
)
2682 dump_uint64( " result=", &req
->result
);
2683 dump_varargs_bytes( ", data=", cur_size
);
2686 static void dump_set_win_timer_request( const struct set_win_timer_request
*req
)
2688 fprintf( stderr
, " win=%08x", req
->win
);
2689 fprintf( stderr
, ", msg=%08x", req
->msg
);
2690 fprintf( stderr
, ", rate=%08x", req
->rate
);
2691 dump_uint64( ", id=", &req
->id
);
2692 dump_uint64( ", lparam=", &req
->lparam
);
2695 static void dump_set_win_timer_reply( const struct set_win_timer_reply
*req
)
2697 dump_uint64( " id=", &req
->id
);
2700 static void dump_kill_win_timer_request( const struct kill_win_timer_request
*req
)
2702 fprintf( stderr
, " win=%08x", req
->win
);
2703 dump_uint64( ", id=", &req
->id
);
2704 fprintf( stderr
, ", msg=%08x", req
->msg
);
2707 static void dump_is_window_hung_request( const struct is_window_hung_request
*req
)
2709 fprintf( stderr
, " win=%08x", req
->win
);
2712 static void dump_is_window_hung_reply( const struct is_window_hung_reply
*req
)
2714 fprintf( stderr
, " is_hung=%d", req
->is_hung
);
2717 static void dump_get_serial_info_request( const struct get_serial_info_request
*req
)
2719 fprintf( stderr
, " handle=%04x", req
->handle
);
2720 fprintf( stderr
, ", flags=%d", req
->flags
);
2723 static void dump_get_serial_info_reply( const struct get_serial_info_reply
*req
)
2725 fprintf( stderr
, " readinterval=%08x", req
->readinterval
);
2726 fprintf( stderr
, ", readconst=%08x", req
->readconst
);
2727 fprintf( stderr
, ", readmult=%08x", req
->readmult
);
2728 fprintf( stderr
, ", writeconst=%08x", req
->writeconst
);
2729 fprintf( stderr
, ", writemult=%08x", req
->writemult
);
2730 fprintf( stderr
, ", eventmask=%08x", req
->eventmask
);
2731 fprintf( stderr
, ", cookie=%08x", req
->cookie
);
2732 fprintf( stderr
, ", pending_write=%08x", req
->pending_write
);
2735 static void dump_set_serial_info_request( const struct set_serial_info_request
*req
)
2737 fprintf( stderr
, " handle=%04x", req
->handle
);
2738 fprintf( stderr
, ", flags=%d", req
->flags
);
2739 fprintf( stderr
, ", readinterval=%08x", req
->readinterval
);
2740 fprintf( stderr
, ", readconst=%08x", req
->readconst
);
2741 fprintf( stderr
, ", readmult=%08x", req
->readmult
);
2742 fprintf( stderr
, ", writeconst=%08x", req
->writeconst
);
2743 fprintf( stderr
, ", writemult=%08x", req
->writemult
);
2744 fprintf( stderr
, ", eventmask=%08x", req
->eventmask
);
2747 static void dump_register_async_request( const struct register_async_request
*req
)
2749 fprintf( stderr
, " type=%d", req
->type
);
2750 dump_async_data( ", async=", &req
->async
);
2751 fprintf( stderr
, ", count=%d", req
->count
);
2754 static void dump_cancel_async_request( const struct cancel_async_request
*req
)
2756 fprintf( stderr
, " handle=%04x", req
->handle
);
2757 dump_uint64( ", iosb=", &req
->iosb
);
2758 fprintf( stderr
, ", only_thread=%d", req
->only_thread
);
2761 static void dump_read_request( const struct read_request
*req
)
2763 fprintf( stderr
, " blocking=%d", req
->blocking
);
2764 dump_async_data( ", async=", &req
->async
);
2765 dump_uint64( ", pos=", &req
->pos
);
2768 static void dump_read_reply( const struct read_reply
*req
)
2770 fprintf( stderr
, " wait=%04x", req
->wait
);
2771 fprintf( stderr
, ", options=%08x", req
->options
);
2772 dump_varargs_bytes( ", data=", cur_size
);
2775 static void dump_write_request( const struct write_request
*req
)
2777 fprintf( stderr
, " blocking=%d", req
->blocking
);
2778 dump_async_data( ", async=", &req
->async
);
2779 dump_uint64( ", pos=", &req
->pos
);
2780 dump_varargs_bytes( ", data=", cur_size
);
2783 static void dump_write_reply( const struct write_reply
*req
)
2785 fprintf( stderr
, " wait=%04x", req
->wait
);
2786 fprintf( stderr
, ", options=%08x", req
->options
);
2787 fprintf( stderr
, ", size=%u", req
->size
);
2790 static void dump_ioctl_request( const struct ioctl_request
*req
)
2792 dump_ioctl_code( " code=", &req
->code
);
2793 dump_async_data( ", async=", &req
->async
);
2794 fprintf( stderr
, ", blocking=%d", req
->blocking
);
2795 dump_varargs_bytes( ", in_data=", cur_size
);
2798 static void dump_ioctl_reply( const struct ioctl_reply
*req
)
2800 fprintf( stderr
, " wait=%04x", req
->wait
);
2801 fprintf( stderr
, ", options=%08x", req
->options
);
2802 dump_varargs_bytes( ", out_data=", cur_size
);
2805 static void dump_set_irp_result_request( const struct set_irp_result_request
*req
)
2807 fprintf( stderr
, " manager=%04x", req
->manager
);
2808 fprintf( stderr
, ", handle=%04x", req
->handle
);
2809 fprintf( stderr
, ", status=%08x", req
->status
);
2810 fprintf( stderr
, ", size=%u", req
->size
);
2811 dump_varargs_bytes( ", data=", cur_size
);
2814 static void dump_get_irp_result_request( const struct get_irp_result_request
*req
)
2816 fprintf( stderr
, " handle=%04x", req
->handle
);
2817 dump_uint64( ", user_arg=", &req
->user_arg
);
2820 static void dump_get_irp_result_reply( const struct get_irp_result_reply
*req
)
2822 fprintf( stderr
, " size=%u", req
->size
);
2823 dump_varargs_bytes( ", out_data=", cur_size
);
2826 static void dump_create_named_pipe_request( const struct create_named_pipe_request
*req
)
2828 fprintf( stderr
, " access=%08x", req
->access
);
2829 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2830 fprintf( stderr
, ", options=%08x", req
->options
);
2831 fprintf( stderr
, ", sharing=%08x", req
->sharing
);
2832 fprintf( stderr
, ", maxinstances=%08x", req
->maxinstances
);
2833 fprintf( stderr
, ", outsize=%08x", req
->outsize
);
2834 fprintf( stderr
, ", insize=%08x", req
->insize
);
2835 dump_timeout( ", timeout=", &req
->timeout
);
2836 fprintf( stderr
, ", flags=%08x", req
->flags
);
2837 dump_varargs_object_attributes( ", objattr=", cur_size
);
2840 static void dump_create_named_pipe_reply( const struct create_named_pipe_reply
*req
)
2842 fprintf( stderr
, " handle=%04x", req
->handle
);
2845 static void dump_get_named_pipe_info_request( const struct get_named_pipe_info_request
*req
)
2847 fprintf( stderr
, " handle=%04x", req
->handle
);
2850 static void dump_get_named_pipe_info_reply( const struct get_named_pipe_info_reply
*req
)
2852 fprintf( stderr
, " flags=%08x", req
->flags
);
2853 fprintf( stderr
, ", sharing=%08x", req
->sharing
);
2854 fprintf( stderr
, ", maxinstances=%08x", req
->maxinstances
);
2855 fprintf( stderr
, ", instances=%08x", req
->instances
);
2856 fprintf( stderr
, ", outsize=%08x", req
->outsize
);
2857 fprintf( stderr
, ", insize=%08x", req
->insize
);
2860 static void dump_set_named_pipe_info_request( const struct set_named_pipe_info_request
*req
)
2862 fprintf( stderr
, " handle=%04x", req
->handle
);
2863 fprintf( stderr
, ", flags=%08x", req
->flags
);
2866 static void dump_create_window_request( const struct create_window_request
*req
)
2868 fprintf( stderr
, " parent=%08x", req
->parent
);
2869 fprintf( stderr
, ", owner=%08x", req
->owner
);
2870 fprintf( stderr
, ", atom=%04x", req
->atom
);
2871 dump_uint64( ", instance=", &req
->instance
);
2872 dump_varargs_unicode_str( ", class=", cur_size
);
2875 static void dump_create_window_reply( const struct create_window_reply
*req
)
2877 fprintf( stderr
, " handle=%08x", req
->handle
);
2878 fprintf( stderr
, ", parent=%08x", req
->parent
);
2879 fprintf( stderr
, ", owner=%08x", req
->owner
);
2880 fprintf( stderr
, ", extra=%d", req
->extra
);
2881 dump_uint64( ", class_ptr=", &req
->class_ptr
);
2884 static void dump_destroy_window_request( const struct destroy_window_request
*req
)
2886 fprintf( stderr
, " handle=%08x", req
->handle
);
2889 static void dump_get_desktop_window_request( const struct get_desktop_window_request
*req
)
2891 fprintf( stderr
, " force=%d", req
->force
);
2894 static void dump_get_desktop_window_reply( const struct get_desktop_window_reply
*req
)
2896 fprintf( stderr
, " top_window=%08x", req
->top_window
);
2897 fprintf( stderr
, ", msg_window=%08x", req
->msg_window
);
2900 static void dump_set_window_owner_request( const struct set_window_owner_request
*req
)
2902 fprintf( stderr
, " handle=%08x", req
->handle
);
2903 fprintf( stderr
, ", owner=%08x", req
->owner
);
2906 static void dump_set_window_owner_reply( const struct set_window_owner_reply
*req
)
2908 fprintf( stderr
, " full_owner=%08x", req
->full_owner
);
2909 fprintf( stderr
, ", prev_owner=%08x", req
->prev_owner
);
2912 static void dump_get_window_info_request( const struct get_window_info_request
*req
)
2914 fprintf( stderr
, " handle=%08x", req
->handle
);
2917 static void dump_get_window_info_reply( const struct get_window_info_reply
*req
)
2919 fprintf( stderr
, " full_handle=%08x", req
->full_handle
);
2920 fprintf( stderr
, ", last_active=%08x", req
->last_active
);
2921 fprintf( stderr
, ", pid=%04x", req
->pid
);
2922 fprintf( stderr
, ", tid=%04x", req
->tid
);
2923 fprintf( stderr
, ", atom=%04x", req
->atom
);
2924 fprintf( stderr
, ", is_unicode=%d", req
->is_unicode
);
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
);
2964 static void dump_get_window_parents_request( const struct get_window_parents_request
*req
)
2966 fprintf( stderr
, " handle=%08x", req
->handle
);
2969 static void dump_get_window_parents_reply( const struct get_window_parents_reply
*req
)
2971 fprintf( stderr
, " count=%d", req
->count
);
2972 dump_varargs_user_handles( ", parents=", cur_size
);
2975 static void dump_get_window_children_request( const struct get_window_children_request
*req
)
2977 fprintf( stderr
, " desktop=%04x", req
->desktop
);
2978 fprintf( stderr
, ", parent=%08x", req
->parent
);
2979 fprintf( stderr
, ", atom=%04x", req
->atom
);
2980 fprintf( stderr
, ", tid=%04x", req
->tid
);
2981 dump_varargs_unicode_str( ", class=", cur_size
);
2984 static void dump_get_window_children_reply( const struct get_window_children_reply
*req
)
2986 fprintf( stderr
, " count=%d", req
->count
);
2987 dump_varargs_user_handles( ", children=", cur_size
);
2990 static void dump_get_window_children_from_point_request( const struct get_window_children_from_point_request
*req
)
2992 fprintf( stderr
, " parent=%08x", req
->parent
);
2993 fprintf( stderr
, ", x=%d", req
->x
);
2994 fprintf( stderr
, ", y=%d", req
->y
);
2997 static void dump_get_window_children_from_point_reply( const struct get_window_children_from_point_reply
*req
)
2999 fprintf( stderr
, " count=%d", req
->count
);
3000 dump_varargs_user_handles( ", children=", cur_size
);
3003 static void dump_get_window_tree_request( const struct get_window_tree_request
*req
)
3005 fprintf( stderr
, " handle=%08x", req
->handle
);
3008 static void dump_get_window_tree_reply( const struct get_window_tree_reply
*req
)
3010 fprintf( stderr
, " parent=%08x", req
->parent
);
3011 fprintf( stderr
, ", owner=%08x", req
->owner
);
3012 fprintf( stderr
, ", next_sibling=%08x", req
->next_sibling
);
3013 fprintf( stderr
, ", prev_sibling=%08x", req
->prev_sibling
);
3014 fprintf( stderr
, ", first_sibling=%08x", req
->first_sibling
);
3015 fprintf( stderr
, ", last_sibling=%08x", req
->last_sibling
);
3016 fprintf( stderr
, ", first_child=%08x", req
->first_child
);
3017 fprintf( stderr
, ", last_child=%08x", req
->last_child
);
3020 static void dump_set_window_pos_request( const struct set_window_pos_request
*req
)
3022 fprintf( stderr
, " swp_flags=%04x", req
->swp_flags
);
3023 fprintf( stderr
, ", paint_flags=%04x", req
->paint_flags
);
3024 fprintf( stderr
, ", handle=%08x", req
->handle
);
3025 fprintf( stderr
, ", previous=%08x", req
->previous
);
3026 dump_rectangle( ", window=", &req
->window
);
3027 dump_rectangle( ", client=", &req
->client
);
3028 dump_varargs_rectangles( ", valid=", cur_size
);
3031 static void dump_set_window_pos_reply( const struct set_window_pos_reply
*req
)
3033 fprintf( stderr
, " new_style=%08x", req
->new_style
);
3034 fprintf( stderr
, ", new_ex_style=%08x", req
->new_ex_style
);
3035 fprintf( stderr
, ", surface_win=%08x", req
->surface_win
);
3038 static void dump_get_window_rectangles_request( const struct get_window_rectangles_request
*req
)
3040 fprintf( stderr
, " handle=%08x", req
->handle
);
3041 fprintf( stderr
, ", relative=%d", req
->relative
);
3044 static void dump_get_window_rectangles_reply( const struct get_window_rectangles_reply
*req
)
3046 dump_rectangle( " window=", &req
->window
);
3047 dump_rectangle( ", visible=", &req
->visible
);
3048 dump_rectangle( ", client=", &req
->client
);
3051 static void dump_get_window_text_request( const struct get_window_text_request
*req
)
3053 fprintf( stderr
, " handle=%08x", req
->handle
);
3056 static void dump_get_window_text_reply( const struct get_window_text_reply
*req
)
3058 dump_varargs_unicode_str( " text=", cur_size
);
3061 static void dump_set_window_text_request( const struct set_window_text_request
*req
)
3063 fprintf( stderr
, " handle=%08x", req
->handle
);
3064 dump_varargs_unicode_str( ", text=", cur_size
);
3067 static void dump_get_windows_offset_request( const struct get_windows_offset_request
*req
)
3069 fprintf( stderr
, " from=%08x", req
->from
);
3070 fprintf( stderr
, ", to=%08x", req
->to
);
3073 static void dump_get_windows_offset_reply( const struct get_windows_offset_reply
*req
)
3075 fprintf( stderr
, " x=%d", req
->x
);
3076 fprintf( stderr
, ", y=%d", req
->y
);
3077 fprintf( stderr
, ", mirror=%d", req
->mirror
);
3080 static void dump_get_visible_region_request( const struct get_visible_region_request
*req
)
3082 fprintf( stderr
, " window=%08x", req
->window
);
3083 fprintf( stderr
, ", flags=%08x", req
->flags
);
3086 static void dump_get_visible_region_reply( const struct get_visible_region_reply
*req
)
3088 fprintf( stderr
, " top_win=%08x", req
->top_win
);
3089 dump_rectangle( ", top_rect=", &req
->top_rect
);
3090 dump_rectangle( ", win_rect=", &req
->win_rect
);
3091 fprintf( stderr
, ", paint_flags=%08x", req
->paint_flags
);
3092 fprintf( stderr
, ", total_size=%u", req
->total_size
);
3093 dump_varargs_rectangles( ", region=", cur_size
);
3096 static void dump_get_surface_region_request( const struct get_surface_region_request
*req
)
3098 fprintf( stderr
, " window=%08x", req
->window
);
3101 static void dump_get_surface_region_reply( const struct get_surface_region_reply
*req
)
3103 dump_rectangle( " visible_rect=", &req
->visible_rect
);
3104 fprintf( stderr
, ", total_size=%u", req
->total_size
);
3105 dump_varargs_rectangles( ", region=", cur_size
);
3108 static void dump_get_window_region_request( const struct get_window_region_request
*req
)
3110 fprintf( stderr
, " window=%08x", req
->window
);
3113 static void dump_get_window_region_reply( const struct get_window_region_reply
*req
)
3115 fprintf( stderr
, " total_size=%u", req
->total_size
);
3116 dump_varargs_rectangles( ", region=", cur_size
);
3119 static void dump_set_window_region_request( const struct set_window_region_request
*req
)
3121 fprintf( stderr
, " window=%08x", req
->window
);
3122 fprintf( stderr
, ", redraw=%d", req
->redraw
);
3123 dump_varargs_rectangles( ", region=", cur_size
);
3126 static void dump_get_update_region_request( const struct get_update_region_request
*req
)
3128 fprintf( stderr
, " window=%08x", req
->window
);
3129 fprintf( stderr
, ", from_child=%08x", req
->from_child
);
3130 fprintf( stderr
, ", flags=%08x", req
->flags
);
3133 static void dump_get_update_region_reply( const struct get_update_region_reply
*req
)
3135 fprintf( stderr
, " child=%08x", req
->child
);
3136 fprintf( stderr
, ", flags=%08x", req
->flags
);
3137 fprintf( stderr
, ", total_size=%u", req
->total_size
);
3138 dump_varargs_rectangles( ", region=", cur_size
);
3141 static void dump_update_window_zorder_request( const struct update_window_zorder_request
*req
)
3143 fprintf( stderr
, " window=%08x", req
->window
);
3144 dump_rectangle( ", rect=", &req
->rect
);
3147 static void dump_redraw_window_request( const struct redraw_window_request
*req
)
3149 fprintf( stderr
, " window=%08x", req
->window
);
3150 fprintf( stderr
, ", flags=%08x", req
->flags
);
3151 dump_varargs_rectangles( ", region=", cur_size
);
3154 static void dump_set_window_property_request( const struct set_window_property_request
*req
)
3156 fprintf( stderr
, " window=%08x", req
->window
);
3157 dump_uint64( ", data=", &req
->data
);
3158 fprintf( stderr
, ", atom=%04x", req
->atom
);
3159 dump_varargs_unicode_str( ", name=", cur_size
);
3162 static void dump_remove_window_property_request( const struct remove_window_property_request
*req
)
3164 fprintf( stderr
, " window=%08x", req
->window
);
3165 fprintf( stderr
, ", atom=%04x", req
->atom
);
3166 dump_varargs_unicode_str( ", name=", cur_size
);
3169 static void dump_remove_window_property_reply( const struct remove_window_property_reply
*req
)
3171 dump_uint64( " data=", &req
->data
);
3174 static void dump_get_window_property_request( const struct get_window_property_request
*req
)
3176 fprintf( stderr
, " window=%08x", req
->window
);
3177 fprintf( stderr
, ", atom=%04x", req
->atom
);
3178 dump_varargs_unicode_str( ", name=", cur_size
);
3181 static void dump_get_window_property_reply( const struct get_window_property_reply
*req
)
3183 dump_uint64( " data=", &req
->data
);
3186 static void dump_get_window_properties_request( const struct get_window_properties_request
*req
)
3188 fprintf( stderr
, " window=%08x", req
->window
);
3191 static void dump_get_window_properties_reply( const struct get_window_properties_reply
*req
)
3193 fprintf( stderr
, " total=%d", req
->total
);
3194 dump_varargs_properties( ", props=", cur_size
);
3197 static void dump_create_winstation_request( const struct create_winstation_request
*req
)
3199 fprintf( stderr
, " flags=%08x", req
->flags
);
3200 fprintf( stderr
, ", access=%08x", req
->access
);
3201 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3202 dump_varargs_unicode_str( ", name=", cur_size
);
3205 static void dump_create_winstation_reply( const struct create_winstation_reply
*req
)
3207 fprintf( stderr
, " handle=%04x", req
->handle
);
3210 static void dump_open_winstation_request( const struct open_winstation_request
*req
)
3212 fprintf( stderr
, " access=%08x", req
->access
);
3213 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3214 dump_varargs_unicode_str( ", name=", cur_size
);
3217 static void dump_open_winstation_reply( const struct open_winstation_reply
*req
)
3219 fprintf( stderr
, " handle=%04x", req
->handle
);
3222 static void dump_close_winstation_request( const struct close_winstation_request
*req
)
3224 fprintf( stderr
, " handle=%04x", req
->handle
);
3227 static void dump_get_process_winstation_request( const struct get_process_winstation_request
*req
)
3231 static void dump_get_process_winstation_reply( const struct get_process_winstation_reply
*req
)
3233 fprintf( stderr
, " handle=%04x", req
->handle
);
3236 static void dump_set_process_winstation_request( const struct set_process_winstation_request
*req
)
3238 fprintf( stderr
, " handle=%04x", req
->handle
);
3241 static void dump_enum_winstation_request( const struct enum_winstation_request
*req
)
3243 fprintf( stderr
, " index=%08x", req
->index
);
3246 static void dump_enum_winstation_reply( const struct enum_winstation_reply
*req
)
3248 fprintf( stderr
, " next=%08x", req
->next
);
3249 dump_varargs_unicode_str( ", name=", cur_size
);
3252 static void dump_create_desktop_request( const struct create_desktop_request
*req
)
3254 fprintf( stderr
, " flags=%08x", req
->flags
);
3255 fprintf( stderr
, ", access=%08x", req
->access
);
3256 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3257 dump_varargs_unicode_str( ", name=", cur_size
);
3260 static void dump_create_desktop_reply( const struct create_desktop_reply
*req
)
3262 fprintf( stderr
, " handle=%04x", req
->handle
);
3265 static void dump_open_desktop_request( const struct open_desktop_request
*req
)
3267 fprintf( stderr
, " winsta=%04x", req
->winsta
);
3268 fprintf( stderr
, ", flags=%08x", req
->flags
);
3269 fprintf( stderr
, ", access=%08x", req
->access
);
3270 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3271 dump_varargs_unicode_str( ", name=", cur_size
);
3274 static void dump_open_desktop_reply( const struct open_desktop_reply
*req
)
3276 fprintf( stderr
, " handle=%04x", req
->handle
);
3279 static void dump_open_input_desktop_request( const struct open_input_desktop_request
*req
)
3281 fprintf( stderr
, " flags=%08x", req
->flags
);
3282 fprintf( stderr
, ", access=%08x", req
->access
);
3283 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3286 static void dump_open_input_desktop_reply( const struct open_input_desktop_reply
*req
)
3288 fprintf( stderr
, " handle=%04x", req
->handle
);
3291 static void dump_close_desktop_request( const struct close_desktop_request
*req
)
3293 fprintf( stderr
, " handle=%04x", req
->handle
);
3296 static void dump_get_thread_desktop_request( const struct get_thread_desktop_request
*req
)
3298 fprintf( stderr
, " tid=%04x", req
->tid
);
3301 static void dump_get_thread_desktop_reply( const struct get_thread_desktop_reply
*req
)
3303 fprintf( stderr
, " handle=%04x", req
->handle
);
3306 static void dump_set_thread_desktop_request( const struct set_thread_desktop_request
*req
)
3308 fprintf( stderr
, " handle=%04x", req
->handle
);
3311 static void dump_enum_desktop_request( const struct enum_desktop_request
*req
)
3313 fprintf( stderr
, " winstation=%04x", req
->winstation
);
3314 fprintf( stderr
, ", index=%08x", req
->index
);
3317 static void dump_enum_desktop_reply( const struct enum_desktop_reply
*req
)
3319 fprintf( stderr
, " next=%08x", req
->next
);
3320 dump_varargs_unicode_str( ", name=", cur_size
);
3323 static void dump_set_user_object_info_request( const struct set_user_object_info_request
*req
)
3325 fprintf( stderr
, " handle=%04x", req
->handle
);
3326 fprintf( stderr
, ", flags=%08x", req
->flags
);
3327 fprintf( stderr
, ", obj_flags=%08x", req
->obj_flags
);
3330 static void dump_set_user_object_info_reply( const struct set_user_object_info_reply
*req
)
3332 fprintf( stderr
, " is_desktop=%d", req
->is_desktop
);
3333 fprintf( stderr
, ", old_obj_flags=%08x", req
->old_obj_flags
);
3334 dump_varargs_unicode_str( ", name=", cur_size
);
3337 static void dump_register_hotkey_request( const struct register_hotkey_request
*req
)
3339 fprintf( stderr
, " window=%08x", req
->window
);
3340 fprintf( stderr
, ", id=%d", req
->id
);
3341 fprintf( stderr
, ", flags=%08x", req
->flags
);
3342 fprintf( stderr
, ", vkey=%08x", req
->vkey
);
3345 static void dump_register_hotkey_reply( const struct register_hotkey_reply
*req
)
3347 fprintf( stderr
, " replaced=%d", req
->replaced
);
3348 fprintf( stderr
, ", flags=%08x", req
->flags
);
3349 fprintf( stderr
, ", vkey=%08x", req
->vkey
);
3352 static void dump_unregister_hotkey_request( const struct unregister_hotkey_request
*req
)
3354 fprintf( stderr
, " window=%08x", req
->window
);
3355 fprintf( stderr
, ", id=%d", req
->id
);
3358 static void dump_unregister_hotkey_reply( const struct unregister_hotkey_reply
*req
)
3360 fprintf( stderr
, " flags=%08x", req
->flags
);
3361 fprintf( stderr
, ", vkey=%08x", req
->vkey
);
3364 static void dump_attach_thread_input_request( const struct attach_thread_input_request
*req
)
3366 fprintf( stderr
, " tid_from=%04x", req
->tid_from
);
3367 fprintf( stderr
, ", tid_to=%04x", req
->tid_to
);
3368 fprintf( stderr
, ", attach=%d", req
->attach
);
3371 static void dump_get_thread_input_request( const struct get_thread_input_request
*req
)
3373 fprintf( stderr
, " tid=%04x", req
->tid
);
3376 static void dump_get_thread_input_reply( const struct get_thread_input_reply
*req
)
3378 fprintf( stderr
, " focus=%08x", req
->focus
);
3379 fprintf( stderr
, ", capture=%08x", req
->capture
);
3380 fprintf( stderr
, ", active=%08x", req
->active
);
3381 fprintf( stderr
, ", foreground=%08x", req
->foreground
);
3382 fprintf( stderr
, ", menu_owner=%08x", req
->menu_owner
);
3383 fprintf( stderr
, ", move_size=%08x", req
->move_size
);
3384 fprintf( stderr
, ", caret=%08x", req
->caret
);
3385 fprintf( stderr
, ", cursor=%08x", req
->cursor
);
3386 fprintf( stderr
, ", show_count=%d", req
->show_count
);
3387 dump_rectangle( ", rect=", &req
->rect
);
3390 static void dump_get_last_input_time_request( const struct get_last_input_time_request
*req
)
3394 static void dump_get_last_input_time_reply( const struct get_last_input_time_reply
*req
)
3396 fprintf( stderr
, " time=%08x", req
->time
);
3399 static void dump_get_key_state_request( const struct get_key_state_request
*req
)
3401 fprintf( stderr
, " tid=%04x", req
->tid
);
3402 fprintf( stderr
, ", key=%d", req
->key
);
3405 static void dump_get_key_state_reply( const struct get_key_state_reply
*req
)
3407 fprintf( stderr
, " state=%02x", req
->state
);
3408 dump_varargs_bytes( ", keystate=", cur_size
);
3411 static void dump_set_key_state_request( const struct set_key_state_request
*req
)
3413 fprintf( stderr
, " tid=%04x", req
->tid
);
3414 fprintf( stderr
, ", async=%d", req
->async
);
3415 dump_varargs_bytes( ", keystate=", cur_size
);
3418 static void dump_set_foreground_window_request( const struct set_foreground_window_request
*req
)
3420 fprintf( stderr
, " handle=%08x", req
->handle
);
3423 static void dump_set_foreground_window_reply( const struct set_foreground_window_reply
*req
)
3425 fprintf( stderr
, " previous=%08x", req
->previous
);
3426 fprintf( stderr
, ", send_msg_old=%d", req
->send_msg_old
);
3427 fprintf( stderr
, ", send_msg_new=%d", req
->send_msg_new
);
3430 static void dump_set_focus_window_request( const struct set_focus_window_request
*req
)
3432 fprintf( stderr
, " handle=%08x", req
->handle
);
3435 static void dump_set_focus_window_reply( const struct set_focus_window_reply
*req
)
3437 fprintf( stderr
, " previous=%08x", req
->previous
);
3440 static void dump_set_active_window_request( const struct set_active_window_request
*req
)
3442 fprintf( stderr
, " handle=%08x", req
->handle
);
3445 static void dump_set_active_window_reply( const struct set_active_window_reply
*req
)
3447 fprintf( stderr
, " previous=%08x", req
->previous
);
3450 static void dump_set_capture_window_request( const struct set_capture_window_request
*req
)
3452 fprintf( stderr
, " handle=%08x", req
->handle
);
3453 fprintf( stderr
, ", flags=%08x", req
->flags
);
3456 static void dump_set_capture_window_reply( const struct set_capture_window_reply
*req
)
3458 fprintf( stderr
, " previous=%08x", req
->previous
);
3459 fprintf( stderr
, ", full_handle=%08x", req
->full_handle
);
3462 static void dump_set_caret_window_request( const struct set_caret_window_request
*req
)
3464 fprintf( stderr
, " handle=%08x", req
->handle
);
3465 fprintf( stderr
, ", width=%d", req
->width
);
3466 fprintf( stderr
, ", height=%d", req
->height
);
3469 static void dump_set_caret_window_reply( const struct set_caret_window_reply
*req
)
3471 fprintf( stderr
, " previous=%08x", req
->previous
);
3472 dump_rectangle( ", old_rect=", &req
->old_rect
);
3473 fprintf( stderr
, ", old_hide=%d", req
->old_hide
);
3474 fprintf( stderr
, ", old_state=%d", req
->old_state
);
3477 static void dump_set_caret_info_request( const struct set_caret_info_request
*req
)
3479 fprintf( stderr
, " flags=%08x", req
->flags
);
3480 fprintf( stderr
, ", handle=%08x", req
->handle
);
3481 fprintf( stderr
, ", x=%d", req
->x
);
3482 fprintf( stderr
, ", y=%d", req
->y
);
3483 fprintf( stderr
, ", hide=%d", req
->hide
);
3484 fprintf( stderr
, ", state=%d", req
->state
);
3487 static void dump_set_caret_info_reply( const struct set_caret_info_reply
*req
)
3489 fprintf( stderr
, " full_handle=%08x", req
->full_handle
);
3490 dump_rectangle( ", old_rect=", &req
->old_rect
);
3491 fprintf( stderr
, ", old_hide=%d", req
->old_hide
);
3492 fprintf( stderr
, ", old_state=%d", req
->old_state
);
3495 static void dump_set_hook_request( const struct set_hook_request
*req
)
3497 fprintf( stderr
, " id=%d", req
->id
);
3498 fprintf( stderr
, ", pid=%04x", req
->pid
);
3499 fprintf( stderr
, ", tid=%04x", req
->tid
);
3500 fprintf( stderr
, ", event_min=%d", req
->event_min
);
3501 fprintf( stderr
, ", event_max=%d", req
->event_max
);
3502 dump_uint64( ", proc=", &req
->proc
);
3503 fprintf( stderr
, ", flags=%d", req
->flags
);
3504 fprintf( stderr
, ", unicode=%d", req
->unicode
);
3505 dump_varargs_unicode_str( ", module=", cur_size
);
3508 static void dump_set_hook_reply( const struct set_hook_reply
*req
)
3510 fprintf( stderr
, " handle=%08x", req
->handle
);
3511 fprintf( stderr
, ", active_hooks=%08x", req
->active_hooks
);
3514 static void dump_remove_hook_request( const struct remove_hook_request
*req
)
3516 fprintf( stderr
, " handle=%08x", req
->handle
);
3517 dump_uint64( ", proc=", &req
->proc
);
3518 fprintf( stderr
, ", id=%d", req
->id
);
3521 static void dump_remove_hook_reply( const struct remove_hook_reply
*req
)
3523 fprintf( stderr
, " active_hooks=%08x", req
->active_hooks
);
3526 static void dump_start_hook_chain_request( const struct start_hook_chain_request
*req
)
3528 fprintf( stderr
, " id=%d", req
->id
);
3529 fprintf( stderr
, ", event=%d", req
->event
);
3530 fprintf( stderr
, ", window=%08x", req
->window
);
3531 fprintf( stderr
, ", object_id=%d", req
->object_id
);
3532 fprintf( stderr
, ", child_id=%d", req
->child_id
);
3535 static void dump_start_hook_chain_reply( const struct start_hook_chain_reply
*req
)
3537 fprintf( stderr
, " handle=%08x", req
->handle
);
3538 fprintf( stderr
, ", pid=%04x", req
->pid
);
3539 fprintf( stderr
, ", tid=%04x", req
->tid
);
3540 fprintf( stderr
, ", unicode=%d", req
->unicode
);
3541 dump_uint64( ", proc=", &req
->proc
);
3542 fprintf( stderr
, ", active_hooks=%08x", req
->active_hooks
);
3543 dump_varargs_unicode_str( ", module=", cur_size
);
3546 static void dump_finish_hook_chain_request( const struct finish_hook_chain_request
*req
)
3548 fprintf( stderr
, " id=%d", req
->id
);
3551 static void dump_get_hook_info_request( const struct get_hook_info_request
*req
)
3553 fprintf( stderr
, " handle=%08x", req
->handle
);
3554 fprintf( stderr
, ", get_next=%d", req
->get_next
);
3555 fprintf( stderr
, ", event=%d", req
->event
);
3556 fprintf( stderr
, ", window=%08x", req
->window
);
3557 fprintf( stderr
, ", object_id=%d", req
->object_id
);
3558 fprintf( stderr
, ", child_id=%d", req
->child_id
);
3561 static void dump_get_hook_info_reply( const struct get_hook_info_reply
*req
)
3563 fprintf( stderr
, " handle=%08x", req
->handle
);
3564 fprintf( stderr
, ", id=%d", req
->id
);
3565 fprintf( stderr
, ", pid=%04x", req
->pid
);
3566 fprintf( stderr
, ", tid=%04x", req
->tid
);
3567 dump_uint64( ", proc=", &req
->proc
);
3568 fprintf( stderr
, ", unicode=%d", req
->unicode
);
3569 dump_varargs_unicode_str( ", module=", cur_size
);
3572 static void dump_create_class_request( const struct create_class_request
*req
)
3574 fprintf( stderr
, " local=%d", req
->local
);
3575 fprintf( stderr
, ", atom=%04x", req
->atom
);
3576 fprintf( stderr
, ", style=%08x", req
->style
);
3577 dump_uint64( ", instance=", &req
->instance
);
3578 fprintf( stderr
, ", extra=%d", req
->extra
);
3579 fprintf( stderr
, ", win_extra=%d", req
->win_extra
);
3580 dump_uint64( ", client_ptr=", &req
->client_ptr
);
3581 dump_varargs_unicode_str( ", name=", cur_size
);
3584 static void dump_create_class_reply( const struct create_class_reply
*req
)
3586 fprintf( stderr
, " atom=%04x", req
->atom
);
3589 static void dump_destroy_class_request( const struct destroy_class_request
*req
)
3591 fprintf( stderr
, " atom=%04x", req
->atom
);
3592 dump_uint64( ", instance=", &req
->instance
);
3593 dump_varargs_unicode_str( ", name=", cur_size
);
3596 static void dump_destroy_class_reply( const struct destroy_class_reply
*req
)
3598 dump_uint64( " client_ptr=", &req
->client_ptr
);
3601 static void dump_set_class_info_request( const struct set_class_info_request
*req
)
3603 fprintf( stderr
, " window=%08x", req
->window
);
3604 fprintf( stderr
, ", flags=%08x", req
->flags
);
3605 fprintf( stderr
, ", atom=%04x", req
->atom
);
3606 fprintf( stderr
, ", style=%08x", req
->style
);
3607 fprintf( stderr
, ", win_extra=%d", req
->win_extra
);
3608 dump_uint64( ", instance=", &req
->instance
);
3609 fprintf( stderr
, ", extra_offset=%d", req
->extra_offset
);
3610 fprintf( stderr
, ", extra_size=%u", req
->extra_size
);
3611 dump_uint64( ", extra_value=", &req
->extra_value
);
3614 static void dump_set_class_info_reply( const struct set_class_info_reply
*req
)
3616 fprintf( stderr
, " old_atom=%04x", req
->old_atom
);
3617 fprintf( stderr
, ", old_style=%08x", req
->old_style
);
3618 fprintf( stderr
, ", old_extra=%d", req
->old_extra
);
3619 fprintf( stderr
, ", old_win_extra=%d", req
->old_win_extra
);
3620 dump_uint64( ", old_instance=", &req
->old_instance
);
3621 dump_uint64( ", old_extra_value=", &req
->old_extra_value
);
3624 static void dump_set_clipboard_info_request( const struct set_clipboard_info_request
*req
)
3626 fprintf( stderr
, " flags=%08x", req
->flags
);
3627 fprintf( stderr
, ", clipboard=%08x", req
->clipboard
);
3628 fprintf( stderr
, ", owner=%08x", req
->owner
);
3629 fprintf( stderr
, ", viewer=%08x", req
->viewer
);
3630 fprintf( stderr
, ", seqno=%08x", req
->seqno
);
3633 static void dump_set_clipboard_info_reply( const struct set_clipboard_info_reply
*req
)
3635 fprintf( stderr
, " flags=%08x", req
->flags
);
3636 fprintf( stderr
, ", old_clipboard=%08x", req
->old_clipboard
);
3637 fprintf( stderr
, ", old_owner=%08x", req
->old_owner
);
3638 fprintf( stderr
, ", old_viewer=%08x", req
->old_viewer
);
3639 fprintf( stderr
, ", seqno=%08x", req
->seqno
);
3642 static void dump_open_token_request( const struct open_token_request
*req
)
3644 fprintf( stderr
, " handle=%04x", req
->handle
);
3645 fprintf( stderr
, ", access=%08x", req
->access
);
3646 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3647 fprintf( stderr
, ", flags=%08x", req
->flags
);
3650 static void dump_open_token_reply( const struct open_token_reply
*req
)
3652 fprintf( stderr
, " token=%04x", req
->token
);
3655 static void dump_set_global_windows_request( const struct set_global_windows_request
*req
)
3657 fprintf( stderr
, " flags=%08x", req
->flags
);
3658 fprintf( stderr
, ", shell_window=%08x", req
->shell_window
);
3659 fprintf( stderr
, ", shell_listview=%08x", req
->shell_listview
);
3660 fprintf( stderr
, ", progman_window=%08x", req
->progman_window
);
3661 fprintf( stderr
, ", taskman_window=%08x", req
->taskman_window
);
3664 static void dump_set_global_windows_reply( const struct set_global_windows_reply
*req
)
3666 fprintf( stderr
, " old_shell_window=%08x", req
->old_shell_window
);
3667 fprintf( stderr
, ", old_shell_listview=%08x", req
->old_shell_listview
);
3668 fprintf( stderr
, ", old_progman_window=%08x", req
->old_progman_window
);
3669 fprintf( stderr
, ", old_taskman_window=%08x", req
->old_taskman_window
);
3672 static void dump_adjust_token_privileges_request( const struct adjust_token_privileges_request
*req
)
3674 fprintf( stderr
, " handle=%04x", req
->handle
);
3675 fprintf( stderr
, ", disable_all=%d", req
->disable_all
);
3676 fprintf( stderr
, ", get_modified_state=%d", req
->get_modified_state
);
3677 dump_varargs_LUID_AND_ATTRIBUTES( ", privileges=", cur_size
);
3680 static void dump_adjust_token_privileges_reply( const struct adjust_token_privileges_reply
*req
)
3682 fprintf( stderr
, " len=%08x", req
->len
);
3683 dump_varargs_LUID_AND_ATTRIBUTES( ", privileges=", cur_size
);
3686 static void dump_get_token_privileges_request( const struct get_token_privileges_request
*req
)
3688 fprintf( stderr
, " handle=%04x", req
->handle
);
3691 static void dump_get_token_privileges_reply( const struct get_token_privileges_reply
*req
)
3693 fprintf( stderr
, " len=%08x", req
->len
);
3694 dump_varargs_LUID_AND_ATTRIBUTES( ", privileges=", cur_size
);
3697 static void dump_check_token_privileges_request( const struct check_token_privileges_request
*req
)
3699 fprintf( stderr
, " handle=%04x", req
->handle
);
3700 fprintf( stderr
, ", all_required=%d", req
->all_required
);
3701 dump_varargs_LUID_AND_ATTRIBUTES( ", privileges=", cur_size
);
3704 static void dump_check_token_privileges_reply( const struct check_token_privileges_reply
*req
)
3706 fprintf( stderr
, " has_privileges=%d", req
->has_privileges
);
3707 dump_varargs_LUID_AND_ATTRIBUTES( ", privileges=", cur_size
);
3710 static void dump_duplicate_token_request( const struct duplicate_token_request
*req
)
3712 fprintf( stderr
, " handle=%04x", req
->handle
);
3713 fprintf( stderr
, ", access=%08x", req
->access
);
3714 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3715 fprintf( stderr
, ", primary=%d", req
->primary
);
3716 fprintf( stderr
, ", impersonation_level=%d", req
->impersonation_level
);
3719 static void dump_duplicate_token_reply( const struct duplicate_token_reply
*req
)
3721 fprintf( stderr
, " new_handle=%04x", req
->new_handle
);
3724 static void dump_access_check_request( const struct access_check_request
*req
)
3726 fprintf( stderr
, " handle=%04x", req
->handle
);
3727 fprintf( stderr
, ", desired_access=%08x", req
->desired_access
);
3728 fprintf( stderr
, ", mapping_read=%08x", req
->mapping_read
);
3729 fprintf( stderr
, ", mapping_write=%08x", req
->mapping_write
);
3730 fprintf( stderr
, ", mapping_execute=%08x", req
->mapping_execute
);
3731 fprintf( stderr
, ", mapping_all=%08x", req
->mapping_all
);
3732 dump_varargs_security_descriptor( ", sd=", cur_size
);
3735 static void dump_access_check_reply( const struct access_check_reply
*req
)
3737 fprintf( stderr
, " access_granted=%08x", req
->access_granted
);
3738 fprintf( stderr
, ", access_status=%08x", req
->access_status
);
3739 fprintf( stderr
, ", privileges_len=%08x", req
->privileges_len
);
3740 dump_varargs_LUID_AND_ATTRIBUTES( ", privileges=", cur_size
);
3743 static void dump_get_token_sid_request( const struct get_token_sid_request
*req
)
3745 fprintf( stderr
, " handle=%04x", req
->handle
);
3746 fprintf( stderr
, ", which_sid=%08x", req
->which_sid
);
3749 static void dump_get_token_sid_reply( const struct get_token_sid_reply
*req
)
3751 fprintf( stderr
, " sid_len=%u", req
->sid_len
);
3752 dump_varargs_SID( ", sid=", cur_size
);
3755 static void dump_get_token_groups_request( const struct get_token_groups_request
*req
)
3757 fprintf( stderr
, " handle=%04x", req
->handle
);
3760 static void dump_get_token_groups_reply( const struct get_token_groups_reply
*req
)
3762 fprintf( stderr
, " user_len=%u", req
->user_len
);
3763 dump_varargs_token_groups( ", user=", cur_size
);
3766 static void dump_get_token_default_dacl_request( const struct get_token_default_dacl_request
*req
)
3768 fprintf( stderr
, " handle=%04x", req
->handle
);
3771 static void dump_get_token_default_dacl_reply( const struct get_token_default_dacl_reply
*req
)
3773 fprintf( stderr
, " acl_len=%u", req
->acl_len
);
3774 dump_varargs_ACL( ", acl=", cur_size
);
3777 static void dump_set_token_default_dacl_request( const struct set_token_default_dacl_request
*req
)
3779 fprintf( stderr
, " handle=%04x", req
->handle
);
3780 dump_varargs_ACL( ", acl=", cur_size
);
3783 static void dump_set_security_object_request( const struct set_security_object_request
*req
)
3785 fprintf( stderr
, " handle=%04x", req
->handle
);
3786 fprintf( stderr
, ", security_info=%08x", req
->security_info
);
3787 dump_varargs_security_descriptor( ", sd=", cur_size
);
3790 static void dump_get_security_object_request( const struct get_security_object_request
*req
)
3792 fprintf( stderr
, " handle=%04x", req
->handle
);
3793 fprintf( stderr
, ", security_info=%08x", req
->security_info
);
3796 static void dump_get_security_object_reply( const struct get_security_object_reply
*req
)
3798 fprintf( stderr
, " sd_len=%08x", req
->sd_len
);
3799 dump_varargs_security_descriptor( ", sd=", cur_size
);
3802 static void dump_create_mailslot_request( const struct create_mailslot_request
*req
)
3804 fprintf( stderr
, " access=%08x", req
->access
);
3805 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3806 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
3807 dump_timeout( ", read_timeout=", &req
->read_timeout
);
3808 fprintf( stderr
, ", max_msgsize=%08x", req
->max_msgsize
);
3809 dump_varargs_unicode_str( ", name=", cur_size
);
3812 static void dump_create_mailslot_reply( const struct create_mailslot_reply
*req
)
3814 fprintf( stderr
, " handle=%04x", req
->handle
);
3817 static void dump_set_mailslot_info_request( const struct set_mailslot_info_request
*req
)
3819 fprintf( stderr
, " handle=%04x", req
->handle
);
3820 dump_timeout( ", read_timeout=", &req
->read_timeout
);
3821 fprintf( stderr
, ", flags=%08x", req
->flags
);
3824 static void dump_set_mailslot_info_reply( const struct set_mailslot_info_reply
*req
)
3826 dump_timeout( " read_timeout=", &req
->read_timeout
);
3827 fprintf( stderr
, ", max_msgsize=%08x", req
->max_msgsize
);
3830 static void dump_create_directory_request( const struct create_directory_request
*req
)
3832 fprintf( stderr
, " access=%08x", req
->access
);
3833 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3834 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
3835 dump_varargs_unicode_str( ", directory_name=", cur_size
);
3838 static void dump_create_directory_reply( const struct create_directory_reply
*req
)
3840 fprintf( stderr
, " handle=%04x", req
->handle
);
3843 static void dump_open_directory_request( const struct open_directory_request
*req
)
3845 fprintf( stderr
, " access=%08x", req
->access
);
3846 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3847 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
3848 dump_varargs_unicode_str( ", directory_name=", cur_size
);
3851 static void dump_open_directory_reply( const struct open_directory_reply
*req
)
3853 fprintf( stderr
, " handle=%04x", req
->handle
);
3856 static void dump_get_directory_entry_request( const struct get_directory_entry_request
*req
)
3858 fprintf( stderr
, " handle=%04x", req
->handle
);
3859 fprintf( stderr
, ", index=%08x", req
->index
);
3862 static void dump_get_directory_entry_reply( const struct get_directory_entry_reply
*req
)
3864 fprintf( stderr
, " name_len=%u", req
->name_len
);
3865 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->name_len
) );
3866 dump_varargs_unicode_str( ", type=", cur_size
);
3869 static void dump_create_symlink_request( const struct create_symlink_request
*req
)
3871 fprintf( stderr
, " access=%08x", req
->access
);
3872 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3873 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
3874 fprintf( stderr
, ", name_len=%u", req
->name_len
);
3875 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->name_len
) );
3876 dump_varargs_unicode_str( ", target_name=", cur_size
);
3879 static void dump_create_symlink_reply( const struct create_symlink_reply
*req
)
3881 fprintf( stderr
, " handle=%04x", req
->handle
);
3884 static void dump_open_symlink_request( const struct open_symlink_request
*req
)
3886 fprintf( stderr
, " access=%08x", req
->access
);
3887 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3888 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
3889 dump_varargs_unicode_str( ", name=", cur_size
);
3892 static void dump_open_symlink_reply( const struct open_symlink_reply
*req
)
3894 fprintf( stderr
, " handle=%04x", req
->handle
);
3897 static void dump_query_symlink_request( const struct query_symlink_request
*req
)
3899 fprintf( stderr
, " handle=%04x", req
->handle
);
3902 static void dump_query_symlink_reply( const struct query_symlink_reply
*req
)
3904 fprintf( stderr
, " total=%u", req
->total
);
3905 dump_varargs_unicode_str( ", target_name=", cur_size
);
3908 static void dump_get_object_info_request( const struct get_object_info_request
*req
)
3910 fprintf( stderr
, " handle=%04x", req
->handle
);
3913 static void dump_get_object_info_reply( const struct get_object_info_reply
*req
)
3915 fprintf( stderr
, " access=%08x", req
->access
);
3916 fprintf( stderr
, ", ref_count=%08x", req
->ref_count
);
3917 fprintf( stderr
, ", handle_count=%08x", req
->handle_count
);
3918 fprintf( stderr
, ", total=%u", req
->total
);
3919 dump_varargs_unicode_str( ", name=", cur_size
);
3922 static void dump_unlink_object_request( const struct unlink_object_request
*req
)
3924 fprintf( stderr
, " handle=%04x", req
->handle
);
3927 static void dump_get_token_impersonation_level_request( const struct get_token_impersonation_level_request
*req
)
3929 fprintf( stderr
, " handle=%04x", req
->handle
);
3932 static void dump_get_token_impersonation_level_reply( const struct get_token_impersonation_level_reply
*req
)
3934 fprintf( stderr
, " impersonation_level=%d", req
->impersonation_level
);
3937 static void dump_allocate_locally_unique_id_request( const struct allocate_locally_unique_id_request
*req
)
3941 static void dump_allocate_locally_unique_id_reply( const struct allocate_locally_unique_id_reply
*req
)
3943 dump_luid( " luid=", &req
->luid
);
3946 static void dump_create_device_manager_request( const struct create_device_manager_request
*req
)
3948 fprintf( stderr
, " access=%08x", req
->access
);
3949 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3952 static void dump_create_device_manager_reply( const struct create_device_manager_reply
*req
)
3954 fprintf( stderr
, " handle=%04x", req
->handle
);
3957 static void dump_create_device_request( const struct create_device_request
*req
)
3959 fprintf( stderr
, " access=%08x", req
->access
);
3960 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3961 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
3962 dump_uint64( ", user_ptr=", &req
->user_ptr
);
3963 fprintf( stderr
, ", manager=%04x", req
->manager
);
3964 dump_varargs_unicode_str( ", name=", cur_size
);
3967 static void dump_create_device_reply( const struct create_device_reply
*req
)
3969 fprintf( stderr
, " handle=%04x", req
->handle
);
3972 static void dump_delete_device_request( const struct delete_device_request
*req
)
3974 fprintf( stderr
, " handle=%04x", req
->handle
);
3977 static void dump_get_next_device_request_request( const struct get_next_device_request_request
*req
)
3979 fprintf( stderr
, " manager=%04x", req
->manager
);
3980 fprintf( stderr
, ", prev=%04x", req
->prev
);
3981 fprintf( stderr
, ", status=%08x", req
->status
);
3984 static void dump_get_next_device_request_reply( const struct get_next_device_request_reply
*req
)
3986 dump_uint64( " user_ptr=", &req
->user_ptr
);
3987 dump_irp_params( ", params=", &req
->params
);
3988 fprintf( stderr
, ", next=%04x", req
->next
);
3989 fprintf( stderr
, ", client_pid=%04x", req
->client_pid
);
3990 fprintf( stderr
, ", client_tid=%04x", req
->client_tid
);
3991 fprintf( stderr
, ", in_size=%u", req
->in_size
);
3992 fprintf( stderr
, ", out_size=%u", req
->out_size
);
3993 dump_varargs_bytes( ", next_data=", cur_size
);
3996 static void dump_make_process_system_request( const struct make_process_system_request
*req
)
4000 static void dump_make_process_system_reply( const struct make_process_system_reply
*req
)
4002 fprintf( stderr
, " event=%04x", req
->event
);
4005 static void dump_get_token_statistics_request( const struct get_token_statistics_request
*req
)
4007 fprintf( stderr
, " handle=%04x", req
->handle
);
4010 static void dump_get_token_statistics_reply( const struct get_token_statistics_reply
*req
)
4012 dump_luid( " token_id=", &req
->token_id
);
4013 dump_luid( ", modified_id=", &req
->modified_id
);
4014 fprintf( stderr
, ", primary=%d", req
->primary
);
4015 fprintf( stderr
, ", impersonation_level=%d", req
->impersonation_level
);
4016 fprintf( stderr
, ", group_count=%d", req
->group_count
);
4017 fprintf( stderr
, ", privilege_count=%d", req
->privilege_count
);
4020 static void dump_create_completion_request( const struct create_completion_request
*req
)
4022 fprintf( stderr
, " access=%08x", req
->access
);
4023 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
4024 fprintf( stderr
, ", concurrent=%08x", req
->concurrent
);
4025 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
4026 dump_varargs_unicode_str( ", filename=", cur_size
);
4029 static void dump_create_completion_reply( const struct create_completion_reply
*req
)
4031 fprintf( stderr
, " handle=%04x", req
->handle
);
4034 static void dump_open_completion_request( const struct open_completion_request
*req
)
4036 fprintf( stderr
, " access=%08x", req
->access
);
4037 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
4038 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
4039 dump_varargs_unicode_str( ", filename=", cur_size
);
4042 static void dump_open_completion_reply( const struct open_completion_reply
*req
)
4044 fprintf( stderr
, " handle=%04x", req
->handle
);
4047 static void dump_add_completion_request( const struct add_completion_request
*req
)
4049 fprintf( stderr
, " handle=%04x", req
->handle
);
4050 dump_uint64( ", ckey=", &req
->ckey
);
4051 dump_uint64( ", cvalue=", &req
->cvalue
);
4052 dump_uint64( ", information=", &req
->information
);
4053 fprintf( stderr
, ", status=%08x", req
->status
);
4056 static void dump_remove_completion_request( const struct remove_completion_request
*req
)
4058 fprintf( stderr
, " handle=%04x", req
->handle
);
4061 static void dump_remove_completion_reply( const struct remove_completion_reply
*req
)
4063 dump_uint64( " ckey=", &req
->ckey
);
4064 dump_uint64( ", cvalue=", &req
->cvalue
);
4065 dump_uint64( ", information=", &req
->information
);
4066 fprintf( stderr
, ", status=%08x", req
->status
);
4069 static void dump_query_completion_request( const struct query_completion_request
*req
)
4071 fprintf( stderr
, " handle=%04x", req
->handle
);
4074 static void dump_query_completion_reply( const struct query_completion_reply
*req
)
4076 fprintf( stderr
, " depth=%08x", req
->depth
);
4079 static void dump_set_completion_info_request( const struct set_completion_info_request
*req
)
4081 fprintf( stderr
, " handle=%04x", req
->handle
);
4082 dump_uint64( ", ckey=", &req
->ckey
);
4083 fprintf( stderr
, ", chandle=%04x", req
->chandle
);
4086 static void dump_add_fd_completion_request( const struct add_fd_completion_request
*req
)
4088 fprintf( stderr
, " handle=%04x", req
->handle
);
4089 dump_uint64( ", cvalue=", &req
->cvalue
);
4090 dump_uint64( ", information=", &req
->information
);
4091 fprintf( stderr
, ", status=%08x", req
->status
);
4094 static void dump_get_window_layered_info_request( const struct get_window_layered_info_request
*req
)
4096 fprintf( stderr
, " handle=%08x", req
->handle
);
4099 static void dump_get_window_layered_info_reply( const struct get_window_layered_info_reply
*req
)
4101 fprintf( stderr
, " color_key=%08x", req
->color_key
);
4102 fprintf( stderr
, ", alpha=%08x", req
->alpha
);
4103 fprintf( stderr
, ", flags=%08x", req
->flags
);
4106 static void dump_set_window_layered_info_request( const struct set_window_layered_info_request
*req
)
4108 fprintf( stderr
, " handle=%08x", req
->handle
);
4109 fprintf( stderr
, ", color_key=%08x", req
->color_key
);
4110 fprintf( stderr
, ", alpha=%08x", req
->alpha
);
4111 fprintf( stderr
, ", flags=%08x", req
->flags
);
4114 static void dump_alloc_user_handle_request( const struct alloc_user_handle_request
*req
)
4118 static void dump_alloc_user_handle_reply( const struct alloc_user_handle_reply
*req
)
4120 fprintf( stderr
, " handle=%08x", req
->handle
);
4123 static void dump_free_user_handle_request( const struct free_user_handle_request
*req
)
4125 fprintf( stderr
, " handle=%08x", req
->handle
);
4128 static void dump_set_cursor_request( const struct set_cursor_request
*req
)
4130 fprintf( stderr
, " flags=%08x", req
->flags
);
4131 fprintf( stderr
, ", handle=%08x", req
->handle
);
4132 fprintf( stderr
, ", show_count=%d", req
->show_count
);
4133 fprintf( stderr
, ", x=%d", req
->x
);
4134 fprintf( stderr
, ", y=%d", req
->y
);
4135 dump_rectangle( ", clip=", &req
->clip
);
4136 fprintf( stderr
, ", clip_msg=%08x", req
->clip_msg
);
4139 static void dump_set_cursor_reply( const struct set_cursor_reply
*req
)
4141 fprintf( stderr
, " prev_handle=%08x", req
->prev_handle
);
4142 fprintf( stderr
, ", prev_count=%d", req
->prev_count
);
4143 fprintf( stderr
, ", prev_x=%d", req
->prev_x
);
4144 fprintf( stderr
, ", prev_y=%d", req
->prev_y
);
4145 fprintf( stderr
, ", new_x=%d", req
->new_x
);
4146 fprintf( stderr
, ", new_y=%d", req
->new_y
);
4147 dump_rectangle( ", new_clip=", &req
->new_clip
);
4148 fprintf( stderr
, ", last_change=%08x", req
->last_change
);
4151 static void dump_update_rawinput_devices_request( const struct update_rawinput_devices_request
*req
)
4153 dump_varargs_rawinput_devices( " devices=", cur_size
);
4156 static void dump_get_suspend_context_request( const struct get_suspend_context_request
*req
)
4160 static void dump_get_suspend_context_reply( const struct get_suspend_context_reply
*req
)
4162 dump_varargs_context( " context=", cur_size
);
4165 static void dump_set_suspend_context_request( const struct set_suspend_context_request
*req
)
4167 dump_varargs_context( " context=", cur_size
);
4170 static void dump_create_job_request( const struct create_job_request
*req
)
4172 fprintf( stderr
, " access=%08x", req
->access
);
4173 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
4174 dump_varargs_object_attributes( ", objattr=", cur_size
);
4177 static void dump_create_job_reply( const struct create_job_reply
*req
)
4179 fprintf( stderr
, " handle=%04x", req
->handle
);
4182 static void dump_assign_job_request( const struct assign_job_request
*req
)
4184 fprintf( stderr
, " job=%04x", req
->job
);
4185 fprintf( stderr
, ", process=%04x", req
->process
);
4188 static void dump_process_in_job_request( const struct process_in_job_request
*req
)
4190 fprintf( stderr
, " job=%04x", req
->job
);
4191 fprintf( stderr
, ", process=%04x", req
->process
);
4194 static void dump_set_job_limits_request( const struct set_job_limits_request
*req
)
4196 fprintf( stderr
, " handle=%04x", req
->handle
);
4197 fprintf( stderr
, ", limit_flags=%08x", req
->limit_flags
);
4200 static void dump_set_job_completion_port_request( const struct set_job_completion_port_request
*req
)
4202 fprintf( stderr
, " job=%04x", req
->job
);
4203 fprintf( stderr
, ", port=%04x", req
->port
);
4204 dump_uint64( ", key=", &req
->key
);
4207 static void dump_terminate_job_request( const struct terminate_job_request
*req
)
4209 fprintf( stderr
, " handle=%04x", req
->handle
);
4210 fprintf( stderr
, ", status=%d", req
->status
);
4213 static const dump_func req_dumpers
[REQ_NB_REQUESTS
] = {
4214 (dump_func
)dump_new_process_request
,
4215 (dump_func
)dump_get_new_process_info_request
,
4216 (dump_func
)dump_new_thread_request
,
4217 (dump_func
)dump_get_startup_info_request
,
4218 (dump_func
)dump_init_process_done_request
,
4219 (dump_func
)dump_init_thread_request
,
4220 (dump_func
)dump_terminate_process_request
,
4221 (dump_func
)dump_terminate_thread_request
,
4222 (dump_func
)dump_get_process_info_request
,
4223 (dump_func
)dump_set_process_info_request
,
4224 (dump_func
)dump_get_thread_info_request
,
4225 (dump_func
)dump_set_thread_info_request
,
4226 (dump_func
)dump_get_dll_info_request
,
4227 (dump_func
)dump_suspend_thread_request
,
4228 (dump_func
)dump_resume_thread_request
,
4229 (dump_func
)dump_load_dll_request
,
4230 (dump_func
)dump_unload_dll_request
,
4231 (dump_func
)dump_queue_apc_request
,
4232 (dump_func
)dump_get_apc_result_request
,
4233 (dump_func
)dump_close_handle_request
,
4234 (dump_func
)dump_set_handle_info_request
,
4235 (dump_func
)dump_dup_handle_request
,
4236 (dump_func
)dump_open_process_request
,
4237 (dump_func
)dump_open_thread_request
,
4238 (dump_func
)dump_select_request
,
4239 (dump_func
)dump_create_event_request
,
4240 (dump_func
)dump_event_op_request
,
4241 (dump_func
)dump_query_event_request
,
4242 (dump_func
)dump_open_event_request
,
4243 (dump_func
)dump_create_keyed_event_request
,
4244 (dump_func
)dump_open_keyed_event_request
,
4245 (dump_func
)dump_create_mutex_request
,
4246 (dump_func
)dump_release_mutex_request
,
4247 (dump_func
)dump_open_mutex_request
,
4248 (dump_func
)dump_create_semaphore_request
,
4249 (dump_func
)dump_release_semaphore_request
,
4250 (dump_func
)dump_query_semaphore_request
,
4251 (dump_func
)dump_open_semaphore_request
,
4252 (dump_func
)dump_create_file_request
,
4253 (dump_func
)dump_open_file_object_request
,
4254 (dump_func
)dump_alloc_file_handle_request
,
4255 (dump_func
)dump_get_handle_unix_name_request
,
4256 (dump_func
)dump_get_handle_fd_request
,
4257 (dump_func
)dump_flush_request
,
4258 (dump_func
)dump_lock_file_request
,
4259 (dump_func
)dump_unlock_file_request
,
4260 (dump_func
)dump_create_socket_request
,
4261 (dump_func
)dump_accept_socket_request
,
4262 (dump_func
)dump_accept_into_socket_request
,
4263 (dump_func
)dump_set_socket_event_request
,
4264 (dump_func
)dump_get_socket_event_request
,
4265 (dump_func
)dump_get_socket_info_request
,
4266 (dump_func
)dump_enable_socket_event_request
,
4267 (dump_func
)dump_set_socket_deferred_request
,
4268 (dump_func
)dump_alloc_console_request
,
4269 (dump_func
)dump_free_console_request
,
4270 (dump_func
)dump_get_console_renderer_events_request
,
4271 (dump_func
)dump_open_console_request
,
4272 (dump_func
)dump_get_console_wait_event_request
,
4273 (dump_func
)dump_get_console_mode_request
,
4274 (dump_func
)dump_set_console_mode_request
,
4275 (dump_func
)dump_set_console_input_info_request
,
4276 (dump_func
)dump_get_console_input_info_request
,
4277 (dump_func
)dump_append_console_input_history_request
,
4278 (dump_func
)dump_get_console_input_history_request
,
4279 (dump_func
)dump_create_console_output_request
,
4280 (dump_func
)dump_set_console_output_info_request
,
4281 (dump_func
)dump_get_console_output_info_request
,
4282 (dump_func
)dump_write_console_input_request
,
4283 (dump_func
)dump_read_console_input_request
,
4284 (dump_func
)dump_write_console_output_request
,
4285 (dump_func
)dump_fill_console_output_request
,
4286 (dump_func
)dump_read_console_output_request
,
4287 (dump_func
)dump_move_console_output_request
,
4288 (dump_func
)dump_send_console_signal_request
,
4289 (dump_func
)dump_read_directory_changes_request
,
4290 (dump_func
)dump_read_change_request
,
4291 (dump_func
)dump_create_mapping_request
,
4292 (dump_func
)dump_open_mapping_request
,
4293 (dump_func
)dump_get_mapping_info_request
,
4294 (dump_func
)dump_get_mapping_committed_range_request
,
4295 (dump_func
)dump_add_mapping_committed_range_request
,
4296 (dump_func
)dump_create_snapshot_request
,
4297 (dump_func
)dump_next_process_request
,
4298 (dump_func
)dump_next_thread_request
,
4299 (dump_func
)dump_wait_debug_event_request
,
4300 (dump_func
)dump_queue_exception_event_request
,
4301 (dump_func
)dump_get_exception_status_request
,
4302 (dump_func
)dump_continue_debug_event_request
,
4303 (dump_func
)dump_debug_process_request
,
4304 (dump_func
)dump_debug_break_request
,
4305 (dump_func
)dump_set_debugger_kill_on_exit_request
,
4306 (dump_func
)dump_read_process_memory_request
,
4307 (dump_func
)dump_write_process_memory_request
,
4308 (dump_func
)dump_create_key_request
,
4309 (dump_func
)dump_open_key_request
,
4310 (dump_func
)dump_delete_key_request
,
4311 (dump_func
)dump_flush_key_request
,
4312 (dump_func
)dump_enum_key_request
,
4313 (dump_func
)dump_set_key_value_request
,
4314 (dump_func
)dump_get_key_value_request
,
4315 (dump_func
)dump_enum_key_value_request
,
4316 (dump_func
)dump_delete_key_value_request
,
4317 (dump_func
)dump_load_registry_request
,
4318 (dump_func
)dump_unload_registry_request
,
4319 (dump_func
)dump_save_registry_request
,
4320 (dump_func
)dump_set_registry_notification_request
,
4321 (dump_func
)dump_create_timer_request
,
4322 (dump_func
)dump_open_timer_request
,
4323 (dump_func
)dump_set_timer_request
,
4324 (dump_func
)dump_cancel_timer_request
,
4325 (dump_func
)dump_get_timer_info_request
,
4326 (dump_func
)dump_get_thread_context_request
,
4327 (dump_func
)dump_set_thread_context_request
,
4328 (dump_func
)dump_get_selector_entry_request
,
4329 (dump_func
)dump_add_atom_request
,
4330 (dump_func
)dump_delete_atom_request
,
4331 (dump_func
)dump_find_atom_request
,
4332 (dump_func
)dump_get_atom_information_request
,
4333 (dump_func
)dump_set_atom_information_request
,
4334 (dump_func
)dump_empty_atom_table_request
,
4335 (dump_func
)dump_init_atom_table_request
,
4336 (dump_func
)dump_get_msg_queue_request
,
4337 (dump_func
)dump_set_queue_fd_request
,
4338 (dump_func
)dump_set_queue_mask_request
,
4339 (dump_func
)dump_get_queue_status_request
,
4340 (dump_func
)dump_get_process_idle_event_request
,
4341 (dump_func
)dump_send_message_request
,
4342 (dump_func
)dump_post_quit_message_request
,
4343 (dump_func
)dump_send_hardware_message_request
,
4344 (dump_func
)dump_get_message_request
,
4345 (dump_func
)dump_reply_message_request
,
4346 (dump_func
)dump_accept_hardware_message_request
,
4347 (dump_func
)dump_get_message_reply_request
,
4348 (dump_func
)dump_set_win_timer_request
,
4349 (dump_func
)dump_kill_win_timer_request
,
4350 (dump_func
)dump_is_window_hung_request
,
4351 (dump_func
)dump_get_serial_info_request
,
4352 (dump_func
)dump_set_serial_info_request
,
4353 (dump_func
)dump_register_async_request
,
4354 (dump_func
)dump_cancel_async_request
,
4355 (dump_func
)dump_read_request
,
4356 (dump_func
)dump_write_request
,
4357 (dump_func
)dump_ioctl_request
,
4358 (dump_func
)dump_set_irp_result_request
,
4359 (dump_func
)dump_get_irp_result_request
,
4360 (dump_func
)dump_create_named_pipe_request
,
4361 (dump_func
)dump_get_named_pipe_info_request
,
4362 (dump_func
)dump_set_named_pipe_info_request
,
4363 (dump_func
)dump_create_window_request
,
4364 (dump_func
)dump_destroy_window_request
,
4365 (dump_func
)dump_get_desktop_window_request
,
4366 (dump_func
)dump_set_window_owner_request
,
4367 (dump_func
)dump_get_window_info_request
,
4368 (dump_func
)dump_set_window_info_request
,
4369 (dump_func
)dump_set_parent_request
,
4370 (dump_func
)dump_get_window_parents_request
,
4371 (dump_func
)dump_get_window_children_request
,
4372 (dump_func
)dump_get_window_children_from_point_request
,
4373 (dump_func
)dump_get_window_tree_request
,
4374 (dump_func
)dump_set_window_pos_request
,
4375 (dump_func
)dump_get_window_rectangles_request
,
4376 (dump_func
)dump_get_window_text_request
,
4377 (dump_func
)dump_set_window_text_request
,
4378 (dump_func
)dump_get_windows_offset_request
,
4379 (dump_func
)dump_get_visible_region_request
,
4380 (dump_func
)dump_get_surface_region_request
,
4381 (dump_func
)dump_get_window_region_request
,
4382 (dump_func
)dump_set_window_region_request
,
4383 (dump_func
)dump_get_update_region_request
,
4384 (dump_func
)dump_update_window_zorder_request
,
4385 (dump_func
)dump_redraw_window_request
,
4386 (dump_func
)dump_set_window_property_request
,
4387 (dump_func
)dump_remove_window_property_request
,
4388 (dump_func
)dump_get_window_property_request
,
4389 (dump_func
)dump_get_window_properties_request
,
4390 (dump_func
)dump_create_winstation_request
,
4391 (dump_func
)dump_open_winstation_request
,
4392 (dump_func
)dump_close_winstation_request
,
4393 (dump_func
)dump_get_process_winstation_request
,
4394 (dump_func
)dump_set_process_winstation_request
,
4395 (dump_func
)dump_enum_winstation_request
,
4396 (dump_func
)dump_create_desktop_request
,
4397 (dump_func
)dump_open_desktop_request
,
4398 (dump_func
)dump_open_input_desktop_request
,
4399 (dump_func
)dump_close_desktop_request
,
4400 (dump_func
)dump_get_thread_desktop_request
,
4401 (dump_func
)dump_set_thread_desktop_request
,
4402 (dump_func
)dump_enum_desktop_request
,
4403 (dump_func
)dump_set_user_object_info_request
,
4404 (dump_func
)dump_register_hotkey_request
,
4405 (dump_func
)dump_unregister_hotkey_request
,
4406 (dump_func
)dump_attach_thread_input_request
,
4407 (dump_func
)dump_get_thread_input_request
,
4408 (dump_func
)dump_get_last_input_time_request
,
4409 (dump_func
)dump_get_key_state_request
,
4410 (dump_func
)dump_set_key_state_request
,
4411 (dump_func
)dump_set_foreground_window_request
,
4412 (dump_func
)dump_set_focus_window_request
,
4413 (dump_func
)dump_set_active_window_request
,
4414 (dump_func
)dump_set_capture_window_request
,
4415 (dump_func
)dump_set_caret_window_request
,
4416 (dump_func
)dump_set_caret_info_request
,
4417 (dump_func
)dump_set_hook_request
,
4418 (dump_func
)dump_remove_hook_request
,
4419 (dump_func
)dump_start_hook_chain_request
,
4420 (dump_func
)dump_finish_hook_chain_request
,
4421 (dump_func
)dump_get_hook_info_request
,
4422 (dump_func
)dump_create_class_request
,
4423 (dump_func
)dump_destroy_class_request
,
4424 (dump_func
)dump_set_class_info_request
,
4425 (dump_func
)dump_set_clipboard_info_request
,
4426 (dump_func
)dump_open_token_request
,
4427 (dump_func
)dump_set_global_windows_request
,
4428 (dump_func
)dump_adjust_token_privileges_request
,
4429 (dump_func
)dump_get_token_privileges_request
,
4430 (dump_func
)dump_check_token_privileges_request
,
4431 (dump_func
)dump_duplicate_token_request
,
4432 (dump_func
)dump_access_check_request
,
4433 (dump_func
)dump_get_token_sid_request
,
4434 (dump_func
)dump_get_token_groups_request
,
4435 (dump_func
)dump_get_token_default_dacl_request
,
4436 (dump_func
)dump_set_token_default_dacl_request
,
4437 (dump_func
)dump_set_security_object_request
,
4438 (dump_func
)dump_get_security_object_request
,
4439 (dump_func
)dump_create_mailslot_request
,
4440 (dump_func
)dump_set_mailslot_info_request
,
4441 (dump_func
)dump_create_directory_request
,
4442 (dump_func
)dump_open_directory_request
,
4443 (dump_func
)dump_get_directory_entry_request
,
4444 (dump_func
)dump_create_symlink_request
,
4445 (dump_func
)dump_open_symlink_request
,
4446 (dump_func
)dump_query_symlink_request
,
4447 (dump_func
)dump_get_object_info_request
,
4448 (dump_func
)dump_unlink_object_request
,
4449 (dump_func
)dump_get_token_impersonation_level_request
,
4450 (dump_func
)dump_allocate_locally_unique_id_request
,
4451 (dump_func
)dump_create_device_manager_request
,
4452 (dump_func
)dump_create_device_request
,
4453 (dump_func
)dump_delete_device_request
,
4454 (dump_func
)dump_get_next_device_request_request
,
4455 (dump_func
)dump_make_process_system_request
,
4456 (dump_func
)dump_get_token_statistics_request
,
4457 (dump_func
)dump_create_completion_request
,
4458 (dump_func
)dump_open_completion_request
,
4459 (dump_func
)dump_add_completion_request
,
4460 (dump_func
)dump_remove_completion_request
,
4461 (dump_func
)dump_query_completion_request
,
4462 (dump_func
)dump_set_completion_info_request
,
4463 (dump_func
)dump_add_fd_completion_request
,
4464 (dump_func
)dump_get_window_layered_info_request
,
4465 (dump_func
)dump_set_window_layered_info_request
,
4466 (dump_func
)dump_alloc_user_handle_request
,
4467 (dump_func
)dump_free_user_handle_request
,
4468 (dump_func
)dump_set_cursor_request
,
4469 (dump_func
)dump_update_rawinput_devices_request
,
4470 (dump_func
)dump_get_suspend_context_request
,
4471 (dump_func
)dump_set_suspend_context_request
,
4472 (dump_func
)dump_create_job_request
,
4473 (dump_func
)dump_assign_job_request
,
4474 (dump_func
)dump_process_in_job_request
,
4475 (dump_func
)dump_set_job_limits_request
,
4476 (dump_func
)dump_set_job_completion_port_request
,
4477 (dump_func
)dump_terminate_job_request
,
4480 static const dump_func reply_dumpers
[REQ_NB_REQUESTS
] = {
4481 (dump_func
)dump_new_process_reply
,
4482 (dump_func
)dump_get_new_process_info_reply
,
4483 (dump_func
)dump_new_thread_reply
,
4484 (dump_func
)dump_get_startup_info_reply
,
4486 (dump_func
)dump_init_thread_reply
,
4487 (dump_func
)dump_terminate_process_reply
,
4488 (dump_func
)dump_terminate_thread_reply
,
4489 (dump_func
)dump_get_process_info_reply
,
4491 (dump_func
)dump_get_thread_info_reply
,
4493 (dump_func
)dump_get_dll_info_reply
,
4494 (dump_func
)dump_suspend_thread_reply
,
4495 (dump_func
)dump_resume_thread_reply
,
4498 (dump_func
)dump_queue_apc_reply
,
4499 (dump_func
)dump_get_apc_result_reply
,
4501 (dump_func
)dump_set_handle_info_reply
,
4502 (dump_func
)dump_dup_handle_reply
,
4503 (dump_func
)dump_open_process_reply
,
4504 (dump_func
)dump_open_thread_reply
,
4505 (dump_func
)dump_select_reply
,
4506 (dump_func
)dump_create_event_reply
,
4508 (dump_func
)dump_query_event_reply
,
4509 (dump_func
)dump_open_event_reply
,
4510 (dump_func
)dump_create_keyed_event_reply
,
4511 (dump_func
)dump_open_keyed_event_reply
,
4512 (dump_func
)dump_create_mutex_reply
,
4513 (dump_func
)dump_release_mutex_reply
,
4514 (dump_func
)dump_open_mutex_reply
,
4515 (dump_func
)dump_create_semaphore_reply
,
4516 (dump_func
)dump_release_semaphore_reply
,
4517 (dump_func
)dump_query_semaphore_reply
,
4518 (dump_func
)dump_open_semaphore_reply
,
4519 (dump_func
)dump_create_file_reply
,
4520 (dump_func
)dump_open_file_object_reply
,
4521 (dump_func
)dump_alloc_file_handle_reply
,
4522 (dump_func
)dump_get_handle_unix_name_reply
,
4523 (dump_func
)dump_get_handle_fd_reply
,
4524 (dump_func
)dump_flush_reply
,
4525 (dump_func
)dump_lock_file_reply
,
4527 (dump_func
)dump_create_socket_reply
,
4528 (dump_func
)dump_accept_socket_reply
,
4531 (dump_func
)dump_get_socket_event_reply
,
4532 (dump_func
)dump_get_socket_info_reply
,
4535 (dump_func
)dump_alloc_console_reply
,
4537 (dump_func
)dump_get_console_renderer_events_reply
,
4538 (dump_func
)dump_open_console_reply
,
4539 (dump_func
)dump_get_console_wait_event_reply
,
4540 (dump_func
)dump_get_console_mode_reply
,
4543 (dump_func
)dump_get_console_input_info_reply
,
4545 (dump_func
)dump_get_console_input_history_reply
,
4546 (dump_func
)dump_create_console_output_reply
,
4548 (dump_func
)dump_get_console_output_info_reply
,
4549 (dump_func
)dump_write_console_input_reply
,
4550 (dump_func
)dump_read_console_input_reply
,
4551 (dump_func
)dump_write_console_output_reply
,
4552 (dump_func
)dump_fill_console_output_reply
,
4553 (dump_func
)dump_read_console_output_reply
,
4557 (dump_func
)dump_read_change_reply
,
4558 (dump_func
)dump_create_mapping_reply
,
4559 (dump_func
)dump_open_mapping_reply
,
4560 (dump_func
)dump_get_mapping_info_reply
,
4561 (dump_func
)dump_get_mapping_committed_range_reply
,
4563 (dump_func
)dump_create_snapshot_reply
,
4564 (dump_func
)dump_next_process_reply
,
4565 (dump_func
)dump_next_thread_reply
,
4566 (dump_func
)dump_wait_debug_event_reply
,
4567 (dump_func
)dump_queue_exception_event_reply
,
4568 (dump_func
)dump_get_exception_status_reply
,
4571 (dump_func
)dump_debug_break_reply
,
4573 (dump_func
)dump_read_process_memory_reply
,
4575 (dump_func
)dump_create_key_reply
,
4576 (dump_func
)dump_open_key_reply
,
4579 (dump_func
)dump_enum_key_reply
,
4581 (dump_func
)dump_get_key_value_reply
,
4582 (dump_func
)dump_enum_key_value_reply
,
4588 (dump_func
)dump_create_timer_reply
,
4589 (dump_func
)dump_open_timer_reply
,
4590 (dump_func
)dump_set_timer_reply
,
4591 (dump_func
)dump_cancel_timer_reply
,
4592 (dump_func
)dump_get_timer_info_reply
,
4593 (dump_func
)dump_get_thread_context_reply
,
4594 (dump_func
)dump_set_thread_context_reply
,
4595 (dump_func
)dump_get_selector_entry_reply
,
4596 (dump_func
)dump_add_atom_reply
,
4598 (dump_func
)dump_find_atom_reply
,
4599 (dump_func
)dump_get_atom_information_reply
,
4602 (dump_func
)dump_init_atom_table_reply
,
4603 (dump_func
)dump_get_msg_queue_reply
,
4605 (dump_func
)dump_set_queue_mask_reply
,
4606 (dump_func
)dump_get_queue_status_reply
,
4607 (dump_func
)dump_get_process_idle_event_reply
,
4610 (dump_func
)dump_send_hardware_message_reply
,
4611 (dump_func
)dump_get_message_reply
,
4614 (dump_func
)dump_get_message_reply_reply
,
4615 (dump_func
)dump_set_win_timer_reply
,
4617 (dump_func
)dump_is_window_hung_reply
,
4618 (dump_func
)dump_get_serial_info_reply
,
4622 (dump_func
)dump_read_reply
,
4623 (dump_func
)dump_write_reply
,
4624 (dump_func
)dump_ioctl_reply
,
4626 (dump_func
)dump_get_irp_result_reply
,
4627 (dump_func
)dump_create_named_pipe_reply
,
4628 (dump_func
)dump_get_named_pipe_info_reply
,
4630 (dump_func
)dump_create_window_reply
,
4632 (dump_func
)dump_get_desktop_window_reply
,
4633 (dump_func
)dump_set_window_owner_reply
,
4634 (dump_func
)dump_get_window_info_reply
,
4635 (dump_func
)dump_set_window_info_reply
,
4636 (dump_func
)dump_set_parent_reply
,
4637 (dump_func
)dump_get_window_parents_reply
,
4638 (dump_func
)dump_get_window_children_reply
,
4639 (dump_func
)dump_get_window_children_from_point_reply
,
4640 (dump_func
)dump_get_window_tree_reply
,
4641 (dump_func
)dump_set_window_pos_reply
,
4642 (dump_func
)dump_get_window_rectangles_reply
,
4643 (dump_func
)dump_get_window_text_reply
,
4645 (dump_func
)dump_get_windows_offset_reply
,
4646 (dump_func
)dump_get_visible_region_reply
,
4647 (dump_func
)dump_get_surface_region_reply
,
4648 (dump_func
)dump_get_window_region_reply
,
4650 (dump_func
)dump_get_update_region_reply
,
4654 (dump_func
)dump_remove_window_property_reply
,
4655 (dump_func
)dump_get_window_property_reply
,
4656 (dump_func
)dump_get_window_properties_reply
,
4657 (dump_func
)dump_create_winstation_reply
,
4658 (dump_func
)dump_open_winstation_reply
,
4660 (dump_func
)dump_get_process_winstation_reply
,
4662 (dump_func
)dump_enum_winstation_reply
,
4663 (dump_func
)dump_create_desktop_reply
,
4664 (dump_func
)dump_open_desktop_reply
,
4665 (dump_func
)dump_open_input_desktop_reply
,
4667 (dump_func
)dump_get_thread_desktop_reply
,
4669 (dump_func
)dump_enum_desktop_reply
,
4670 (dump_func
)dump_set_user_object_info_reply
,
4671 (dump_func
)dump_register_hotkey_reply
,
4672 (dump_func
)dump_unregister_hotkey_reply
,
4674 (dump_func
)dump_get_thread_input_reply
,
4675 (dump_func
)dump_get_last_input_time_reply
,
4676 (dump_func
)dump_get_key_state_reply
,
4678 (dump_func
)dump_set_foreground_window_reply
,
4679 (dump_func
)dump_set_focus_window_reply
,
4680 (dump_func
)dump_set_active_window_reply
,
4681 (dump_func
)dump_set_capture_window_reply
,
4682 (dump_func
)dump_set_caret_window_reply
,
4683 (dump_func
)dump_set_caret_info_reply
,
4684 (dump_func
)dump_set_hook_reply
,
4685 (dump_func
)dump_remove_hook_reply
,
4686 (dump_func
)dump_start_hook_chain_reply
,
4688 (dump_func
)dump_get_hook_info_reply
,
4689 (dump_func
)dump_create_class_reply
,
4690 (dump_func
)dump_destroy_class_reply
,
4691 (dump_func
)dump_set_class_info_reply
,
4692 (dump_func
)dump_set_clipboard_info_reply
,
4693 (dump_func
)dump_open_token_reply
,
4694 (dump_func
)dump_set_global_windows_reply
,
4695 (dump_func
)dump_adjust_token_privileges_reply
,
4696 (dump_func
)dump_get_token_privileges_reply
,
4697 (dump_func
)dump_check_token_privileges_reply
,
4698 (dump_func
)dump_duplicate_token_reply
,
4699 (dump_func
)dump_access_check_reply
,
4700 (dump_func
)dump_get_token_sid_reply
,
4701 (dump_func
)dump_get_token_groups_reply
,
4702 (dump_func
)dump_get_token_default_dacl_reply
,
4705 (dump_func
)dump_get_security_object_reply
,
4706 (dump_func
)dump_create_mailslot_reply
,
4707 (dump_func
)dump_set_mailslot_info_reply
,
4708 (dump_func
)dump_create_directory_reply
,
4709 (dump_func
)dump_open_directory_reply
,
4710 (dump_func
)dump_get_directory_entry_reply
,
4711 (dump_func
)dump_create_symlink_reply
,
4712 (dump_func
)dump_open_symlink_reply
,
4713 (dump_func
)dump_query_symlink_reply
,
4714 (dump_func
)dump_get_object_info_reply
,
4716 (dump_func
)dump_get_token_impersonation_level_reply
,
4717 (dump_func
)dump_allocate_locally_unique_id_reply
,
4718 (dump_func
)dump_create_device_manager_reply
,
4719 (dump_func
)dump_create_device_reply
,
4721 (dump_func
)dump_get_next_device_request_reply
,
4722 (dump_func
)dump_make_process_system_reply
,
4723 (dump_func
)dump_get_token_statistics_reply
,
4724 (dump_func
)dump_create_completion_reply
,
4725 (dump_func
)dump_open_completion_reply
,
4727 (dump_func
)dump_remove_completion_reply
,
4728 (dump_func
)dump_query_completion_reply
,
4731 (dump_func
)dump_get_window_layered_info_reply
,
4733 (dump_func
)dump_alloc_user_handle_reply
,
4735 (dump_func
)dump_set_cursor_reply
,
4737 (dump_func
)dump_get_suspend_context_reply
,
4739 (dump_func
)dump_create_job_reply
,
4747 static const char * const req_names
[REQ_NB_REQUESTS
] = {
4749 "get_new_process_info",
4752 "init_process_done",
4754 "terminate_process",
4777 "create_keyed_event",
4783 "release_semaphore",
4788 "alloc_file_handle",
4789 "get_handle_unix_name",
4796 "accept_into_socket",
4800 "enable_socket_event",
4801 "set_socket_deferred",
4804 "get_console_renderer_events",
4806 "get_console_wait_event",
4809 "set_console_input_info",
4810 "get_console_input_info",
4811 "append_console_input_history",
4812 "get_console_input_history",
4813 "create_console_output",
4814 "set_console_output_info",
4815 "get_console_output_info",
4816 "write_console_input",
4817 "read_console_input",
4818 "write_console_output",
4819 "fill_console_output",
4820 "read_console_output",
4821 "move_console_output",
4822 "send_console_signal",
4823 "read_directory_changes",
4828 "get_mapping_committed_range",
4829 "add_mapping_committed_range",
4834 "queue_exception_event",
4835 "get_exception_status",
4836 "continue_debug_event",
4839 "set_debugger_kill_on_exit",
4840 "read_process_memory",
4841 "write_process_memory",
4854 "set_registry_notification",
4860 "get_thread_context",
4861 "set_thread_context",
4862 "get_selector_entry",
4866 "get_atom_information",
4867 "set_atom_information",
4874 "get_process_idle_event",
4876 "post_quit_message",
4877 "send_hardware_message",
4880 "accept_hardware_message",
4881 "get_message_reply",
4894 "create_named_pipe",
4895 "get_named_pipe_info",
4896 "set_named_pipe_info",
4899 "get_desktop_window",
4904 "get_window_parents",
4905 "get_window_children",
4906 "get_window_children_from_point",
4909 "get_window_rectangles",
4912 "get_windows_offset",
4913 "get_visible_region",
4914 "get_surface_region",
4915 "get_window_region",
4916 "set_window_region",
4917 "get_update_region",
4918 "update_window_zorder",
4920 "set_window_property",
4921 "remove_window_property",
4922 "get_window_property",
4923 "get_window_properties",
4924 "create_winstation",
4927 "get_process_winstation",
4928 "set_process_winstation",
4932 "open_input_desktop",
4934 "get_thread_desktop",
4935 "set_thread_desktop",
4937 "set_user_object_info",
4939 "unregister_hotkey",
4940 "attach_thread_input",
4942 "get_last_input_time",
4945 "set_foreground_window",
4947 "set_active_window",
4948 "set_capture_window",
4954 "finish_hook_chain",
4959 "set_clipboard_info",
4961 "set_global_windows",
4962 "adjust_token_privileges",
4963 "get_token_privileges",
4964 "check_token_privileges",
4969 "get_token_default_dacl",
4970 "set_token_default_dacl",
4971 "set_security_object",
4972 "get_security_object",
4974 "set_mailslot_info",
4977 "get_directory_entry",
4983 "get_token_impersonation_level",
4984 "allocate_locally_unique_id",
4985 "create_device_manager",
4988 "get_next_device_request",
4989 "make_process_system",
4990 "get_token_statistics",
4991 "create_completion",
4994 "remove_completion",
4996 "set_completion_info",
4997 "add_fd_completion",
4998 "get_window_layered_info",
4999 "set_window_layered_info",
5000 "alloc_user_handle",
5003 "update_rawinput_devices",
5004 "get_suspend_context",
5005 "set_suspend_context",
5010 "set_job_completion_port",
5020 { "ABANDONED_WAIT_0", STATUS_ABANDONED_WAIT_0
},
5021 { "ACCESS_DENIED", STATUS_ACCESS_DENIED
},
5022 { "ACCESS_VIOLATION", STATUS_ACCESS_VIOLATION
},
5023 { "ADDRESS_ALREADY_ASSOCIATED", STATUS_ADDRESS_ALREADY_ASSOCIATED
},
5024 { "ALERTED", STATUS_ALERTED
},
5025 { "ALIAS_EXISTS", STATUS_ALIAS_EXISTS
},
5026 { "BAD_DEVICE_TYPE", STATUS_BAD_DEVICE_TYPE
},
5027 { "BAD_IMPERSONATION_LEVEL", STATUS_BAD_IMPERSONATION_LEVEL
},
5028 { "BREAKPOINT", STATUS_BREAKPOINT
},
5029 { "BUFFER_OVERFLOW", STATUS_BUFFER_OVERFLOW
},
5030 { "BUFFER_TOO_SMALL", STATUS_BUFFER_TOO_SMALL
},
5031 { "CANCELLED", STATUS_CANCELLED
},
5032 { "CANNOT_DELETE", STATUS_CANNOT_DELETE
},
5033 { "CANT_OPEN_ANONYMOUS", STATUS_CANT_OPEN_ANONYMOUS
},
5034 { "CANT_WAIT", STATUS_CANT_WAIT
},
5035 { "CHILD_MUST_BE_VOLATILE", STATUS_CHILD_MUST_BE_VOLATILE
},
5036 { "CONNECTION_ABORTED", STATUS_CONNECTION_ABORTED
},
5037 { "CONNECTION_DISCONNECTED", STATUS_CONNECTION_DISCONNECTED
},
5038 { "CONNECTION_REFUSED", STATUS_CONNECTION_REFUSED
},
5039 { "CONNECTION_RESET", STATUS_CONNECTION_RESET
},
5040 { "DEBUGGER_INACTIVE", STATUS_DEBUGGER_INACTIVE
},
5041 { "DEVICE_BUSY", STATUS_DEVICE_BUSY
},
5042 { "DIRECTORY_NOT_EMPTY", STATUS_DIRECTORY_NOT_EMPTY
},
5043 { "DISK_FULL", STATUS_DISK_FULL
},
5044 { "DLL_NOT_FOUND", STATUS_DLL_NOT_FOUND
},
5045 { "ERROR_CLASS_ALREADY_EXISTS", 0xc0010000 | ERROR_CLASS_ALREADY_EXISTS
},
5046 { "ERROR_CLASS_DOES_NOT_EXIST", 0xc0010000 | ERROR_CLASS_DOES_NOT_EXIST
},
5047 { "ERROR_CLASS_HAS_WINDOWS", 0xc0010000 | ERROR_CLASS_HAS_WINDOWS
},
5048 { "ERROR_CLIPBOARD_NOT_OPEN", 0xc0010000 | ERROR_CLIPBOARD_NOT_OPEN
},
5049 { "ERROR_HOTKEY_ALREADY_REGISTERED", 0xc0010000 | ERROR_HOTKEY_ALREADY_REGISTERED
},
5050 { "ERROR_HOTKEY_NOT_REGISTERED", 0xc0010000 | ERROR_HOTKEY_NOT_REGISTERED
},
5051 { "ERROR_INVALID_CURSOR_HANDLE", 0xc0010000 | ERROR_INVALID_CURSOR_HANDLE
},
5052 { "ERROR_INVALID_INDEX", 0xc0010000 | ERROR_INVALID_INDEX
},
5053 { "ERROR_INVALID_WINDOW_HANDLE", 0xc0010000 | ERROR_INVALID_WINDOW_HANDLE
},
5054 { "ERROR_WINDOW_OF_OTHER_THREAD", 0xc0010000 | ERROR_WINDOW_OF_OTHER_THREAD
},
5055 { "FILE_DELETED", STATUS_FILE_DELETED
},
5056 { "FILE_IS_A_DIRECTORY", STATUS_FILE_IS_A_DIRECTORY
},
5057 { "FILE_LOCK_CONFLICT", STATUS_FILE_LOCK_CONFLICT
},
5058 { "GENERIC_NOT_MAPPED", STATUS_GENERIC_NOT_MAPPED
},
5059 { "HANDLES_CLOSED", STATUS_HANDLES_CLOSED
},
5060 { "HANDLE_NOT_CLOSABLE", STATUS_HANDLE_NOT_CLOSABLE
},
5061 { "HOST_UNREACHABLE", STATUS_HOST_UNREACHABLE
},
5062 { "ILLEGAL_FUNCTION", STATUS_ILLEGAL_FUNCTION
},
5063 { "INSTANCE_NOT_AVAILABLE", STATUS_INSTANCE_NOT_AVAILABLE
},
5064 { "INSUFFICIENT_RESOURCES", STATUS_INSUFFICIENT_RESOURCES
},
5065 { "INVALID_CID", STATUS_INVALID_CID
},
5066 { "INVALID_DEVICE_REQUEST", STATUS_INVALID_DEVICE_REQUEST
},
5067 { "INVALID_FILE_FOR_SECTION", STATUS_INVALID_FILE_FOR_SECTION
},
5068 { "INVALID_HANDLE", STATUS_INVALID_HANDLE
},
5069 { "INVALID_IMAGE_FORMAT", STATUS_INVALID_IMAGE_FORMAT
},
5070 { "INVALID_IMAGE_NE_FORMAT", STATUS_INVALID_IMAGE_NE_FORMAT
},
5071 { "INVALID_IMAGE_NOT_MZ", STATUS_INVALID_IMAGE_NOT_MZ
},
5072 { "INVALID_IMAGE_PROTECT", STATUS_INVALID_IMAGE_PROTECT
},
5073 { "INVALID_IMAGE_WIN_64", STATUS_INVALID_IMAGE_WIN_64
},
5074 { "INVALID_PARAMETER", STATUS_INVALID_PARAMETER
},
5075 { "INVALID_SECURITY_DESCR", STATUS_INVALID_SECURITY_DESCR
},
5076 { "IO_TIMEOUT", STATUS_IO_TIMEOUT
},
5077 { "KEY_DELETED", STATUS_KEY_DELETED
},
5078 { "MAPPED_FILE_SIZE_ZERO", STATUS_MAPPED_FILE_SIZE_ZERO
},
5079 { "MORE_PROCESSING_REQUIRED", STATUS_MORE_PROCESSING_REQUIRED
},
5080 { "MUTANT_NOT_OWNED", STATUS_MUTANT_NOT_OWNED
},
5081 { "NAME_TOO_LONG", STATUS_NAME_TOO_LONG
},
5082 { "NETWORK_BUSY", STATUS_NETWORK_BUSY
},
5083 { "NETWORK_UNREACHABLE", STATUS_NETWORK_UNREACHABLE
},
5084 { "NOTIFY_ENUM_DIR", STATUS_NOTIFY_ENUM_DIR
},
5085 { "NOT_ALL_ASSIGNED", STATUS_NOT_ALL_ASSIGNED
},
5086 { "NOT_A_DIRECTORY", STATUS_NOT_A_DIRECTORY
},
5087 { "NOT_FOUND", STATUS_NOT_FOUND
},
5088 { "NOT_IMPLEMENTED", STATUS_NOT_IMPLEMENTED
},
5089 { "NOT_REGISTRY_FILE", STATUS_NOT_REGISTRY_FILE
},
5090 { "NOT_SUPPORTED", STATUS_NOT_SUPPORTED
},
5091 { "NO_DATA_DETECTED", STATUS_NO_DATA_DETECTED
},
5092 { "NO_IMPERSONATION_TOKEN", STATUS_NO_IMPERSONATION_TOKEN
},
5093 { "NO_MEMORY", STATUS_NO_MEMORY
},
5094 { "NO_MORE_ENTRIES", STATUS_NO_MORE_ENTRIES
},
5095 { "NO_MORE_FILES", STATUS_NO_MORE_FILES
},
5096 { "NO_SUCH_DEVICE", STATUS_NO_SUCH_DEVICE
},
5097 { "NO_SUCH_FILE", STATUS_NO_SUCH_FILE
},
5098 { "NO_TOKEN", STATUS_NO_TOKEN
},
5099 { "OBJECT_NAME_COLLISION", STATUS_OBJECT_NAME_COLLISION
},
5100 { "OBJECT_NAME_EXISTS", STATUS_OBJECT_NAME_EXISTS
},
5101 { "OBJECT_NAME_INVALID", STATUS_OBJECT_NAME_INVALID
},
5102 { "OBJECT_NAME_NOT_FOUND", STATUS_OBJECT_NAME_NOT_FOUND
},
5103 { "OBJECT_PATH_INVALID", STATUS_OBJECT_PATH_INVALID
},
5104 { "OBJECT_PATH_NOT_FOUND", STATUS_OBJECT_PATH_NOT_FOUND
},
5105 { "OBJECT_PATH_SYNTAX_BAD", STATUS_OBJECT_PATH_SYNTAX_BAD
},
5106 { "OBJECT_TYPE_MISMATCH", STATUS_OBJECT_TYPE_MISMATCH
},
5107 { "PENDING", STATUS_PENDING
},
5108 { "PIPE_BUSY", STATUS_PIPE_BUSY
},
5109 { "PIPE_CONNECTED", STATUS_PIPE_CONNECTED
},
5110 { "PIPE_DISCONNECTED", STATUS_PIPE_DISCONNECTED
},
5111 { "PIPE_LISTENING", STATUS_PIPE_LISTENING
},
5112 { "PIPE_NOT_AVAILABLE", STATUS_PIPE_NOT_AVAILABLE
},
5113 { "PRIVILEGE_NOT_HELD", STATUS_PRIVILEGE_NOT_HELD
},
5114 { "PROCESS_IN_JOB", STATUS_PROCESS_IN_JOB
},
5115 { "PROCESS_IS_TERMINATING", STATUS_PROCESS_IS_TERMINATING
},
5116 { "SECTION_TOO_BIG", STATUS_SECTION_TOO_BIG
},
5117 { "SEMAPHORE_LIMIT_EXCEEDED", STATUS_SEMAPHORE_LIMIT_EXCEEDED
},
5118 { "SHARING_VIOLATION", STATUS_SHARING_VIOLATION
},
5119 { "SHUTDOWN_IN_PROGRESS", STATUS_SHUTDOWN_IN_PROGRESS
},
5120 { "SUSPEND_COUNT_EXCEEDED", STATUS_SUSPEND_COUNT_EXCEEDED
},
5121 { "THREAD_IS_TERMINATING", STATUS_THREAD_IS_TERMINATING
},
5122 { "TIMEOUT", STATUS_TIMEOUT
},
5123 { "TOO_MANY_OPENED_FILES", STATUS_TOO_MANY_OPENED_FILES
},
5124 { "UNSUCCESSFUL", STATUS_UNSUCCESSFUL
},
5125 { "USER_APC", STATUS_USER_APC
},
5126 { "USER_MAPPED_FILE", STATUS_USER_MAPPED_FILE
},
5127 { "VOLUME_DISMOUNTED", STATUS_VOLUME_DISMOUNTED
},
5128 { "WAS_LOCKED", STATUS_WAS_LOCKED
},
5132 /* ### make_requests end ### */
5133 /* Everything above this line is generated automatically by tools/make_requests */
5135 static const char *get_status_name( unsigned int status
)
5138 static char buffer
[10];
5142 for (i
= 0; status_names
[i
].name
; i
++)
5143 if (status_names
[i
].value
== status
) return status_names
[i
].name
;
5145 sprintf( buffer
, "%x", status
);
5149 void trace_request(void)
5151 enum request req
= current
->req
.request_header
.req
;
5152 if (req
< REQ_NB_REQUESTS
)
5154 fprintf( stderr
, "%04x: %s(", current
->id
, req_names
[req
] );
5155 if (req_dumpers
[req
])
5157 cur_data
= get_req_data();
5158 cur_size
= get_req_data_size();
5159 req_dumpers
[req
]( ¤t
->req
);
5161 fprintf( stderr
, " )\n" );
5163 else fprintf( stderr
, "%04x: %d(?)\n", current
->id
, req
);
5166 void trace_reply( enum request req
, const union generic_reply
*reply
)
5168 if (req
< REQ_NB_REQUESTS
)
5170 fprintf( stderr
, "%04x: %s() = %s",
5171 current
->id
, req_names
[req
], get_status_name(current
->error
) );
5172 if (reply_dumpers
[req
])
5174 fprintf( stderr
, " {" );
5175 cur_data
= current
->reply_data
;
5176 cur_size
= reply
->reply_header
.reply_size
;
5177 reply_dumpers
[req
]( reply
);
5178 fprintf( stderr
, " }" );
5180 fputc( '\n', stderr
);
5182 else fprintf( stderr
, "%04x: %d() = %s\n",
5183 current
->id
, req
, get_status_name(current
->error
) );