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
26 #include <sys/types.h>
33 #define WIN32_NO_STATUS
40 #include "wine/condrv.h"
42 #include "ddk/ntddser.h"
50 static const void *cur_data
;
51 static data_size_t cur_size
;
53 static const char *get_status_name( unsigned int status
);
55 /* utility functions */
57 static inline void remove_data( data_size_t size
)
59 cur_data
= (const char *)cur_data
+ size
;
63 static void dump_uints( const char *prefix
, const unsigned int *ptr
, int len
)
65 fprintf( stderr
, "%s{", prefix
);
68 fprintf( stderr
, "%08x", *ptr
++ );
69 if (--len
) fputc( ',', stderr
);
74 static void dump_handles( const char *prefix
, const obj_handle_t
*data
, data_size_t size
)
76 data_size_t len
= size
/ sizeof(*data
);
78 fprintf( stderr
,"%s{", prefix
);
81 fprintf( stderr
, "%04x", *data
++ );
82 if (--len
) fputc( ',', stderr
);
87 static void dump_timeout( const char *prefix
, const timeout_t
*time
)
89 fprintf( stderr
, "%s%s", prefix
, get_timeout_str(*time
) );
92 static void dump_abstime( const char *prefix
, const abstime_t
*when
)
94 timeout_t timeout
= abstime_to_timeout( *when
);
95 dump_timeout( prefix
, &timeout
);
98 static void dump_uint64( const char *prefix
, const unsigned __int64
*val
)
100 if ((unsigned int)*val
!= *val
)
101 fprintf( stderr
, "%s%x%08x", prefix
, (unsigned int)(*val
>> 32), (unsigned int)*val
);
103 fprintf( stderr
, "%s%08x", prefix
, (unsigned int)*val
);
106 static void dump_uint128( const char *prefix
, const unsigned __int64 val
[2] )
108 unsigned __int64 low
= val
[0], high
= val
[1];
110 if ((unsigned int)high
!= high
)
111 fprintf( stderr
, "%s%x%08x%08x%08x", prefix
, (unsigned int)(high
>> 32), (unsigned int)high
,
112 (unsigned int)(low
>> 32), (unsigned int)low
);
114 fprintf( stderr
, "%s%x%08x%08x", prefix
, (unsigned int)high
,
115 (unsigned int)(low
>> 32), (unsigned int)low
);
116 else if ((unsigned int)low
!= low
)
117 fprintf( stderr
, "%s%x%08x", prefix
, (unsigned int)(low
>> 32), (unsigned int)low
);
119 fprintf( stderr
, "%s%x", prefix
, (unsigned int)low
);
122 static void dump_uints64( const char *prefix
, const unsigned __int64
*ptr
, int len
)
124 fprintf( stderr
, "%s{", prefix
);
125 if (len
-- > 0) dump_uint64( "", ptr
++ );
126 while (len
-- > 0) dump_uint64( ",", ptr
++ );
127 fputc( '}', stderr
);
130 static void dump_rectangle( const char *prefix
, const rectangle_t
*rect
)
132 fprintf( stderr
, "%s{%d,%d;%d,%d}", prefix
,
133 rect
->left
, rect
->top
, rect
->right
, rect
->bottom
);
136 static void dump_ioctl_code( const char *prefix
, const ioctl_code_t
*code
)
140 #define CASE(c) case c: fprintf( stderr, "%s%s", prefix, #c ); break
141 CASE(IOCTL_CONDRV_ACTIVATE
);
142 CASE(IOCTL_CONDRV_BIND_PID
);
143 CASE(IOCTL_CONDRV_CTRL_EVENT
);
144 CASE(IOCTL_CONDRV_FILL_OUTPUT
);
145 CASE(IOCTL_CONDRV_GET_INPUT_INFO
);
146 CASE(IOCTL_CONDRV_GET_MODE
);
147 CASE(IOCTL_CONDRV_GET_OUTPUT_INFO
);
148 CASE(IOCTL_CONDRV_GET_TITLE
);
149 CASE(IOCTL_CONDRV_PEEK
);
150 CASE(IOCTL_CONDRV_READ_CONSOLE
);
151 CASE(IOCTL_CONDRV_READ_INPUT
);
152 CASE(IOCTL_CONDRV_READ_OUTPUT
);
153 CASE(IOCTL_CONDRV_SET_MODE
);
154 CASE(IOCTL_CONDRV_SET_OUTPUT_INFO
);
155 CASE(IOCTL_CONDRV_SETUP_INPUT
);
156 CASE(IOCTL_CONDRV_WRITE_CONSOLE
);
157 CASE(IOCTL_CONDRV_WRITE_INPUT
);
158 CASE(IOCTL_CONDRV_WRITE_OUTPUT
);
159 CASE(FSCTL_DISMOUNT_VOLUME
);
160 CASE(FSCTL_PIPE_DISCONNECT
);
161 CASE(FSCTL_PIPE_LISTEN
);
162 CASE(FSCTL_PIPE_PEEK
);
163 CASE(FSCTL_PIPE_WAIT
);
164 CASE(IOCTL_SERIAL_GET_TIMEOUTS
);
165 CASE(IOCTL_SERIAL_GET_WAIT_MASK
);
166 CASE(IOCTL_SERIAL_SET_TIMEOUTS
);
167 CASE(IOCTL_SERIAL_SET_WAIT_MASK
);
168 CASE(WS_SIO_ADDRESS_LIST_CHANGE
);
169 default: fprintf( stderr
, "%s%08x", prefix
, *code
); break;
174 static void dump_apc_call( const char *prefix
, const apc_call_t
*call
)
176 fprintf( stderr
, "%s{", prefix
);
180 fprintf( stderr
, "APC_NONE" );
183 dump_uint64( "APC_USER,func=", &call
->user
.func
);
184 dump_uints64( ",args=", call
->user
.args
, 3 );
187 dump_uint64( "APC_ASYNC_IO,user=", &call
->async_io
.user
);
188 dump_uint64( ",sb=", &call
->async_io
.sb
);
189 fprintf( stderr
, ",status=%s,result=%u", get_status_name(call
->async_io
.status
), call
->async_io
.result
);
191 case APC_VIRTUAL_ALLOC
:
192 dump_uint64( "APC_VIRTUAL_ALLOC,addr=", &call
->virtual_alloc
.addr
);
193 dump_uint64( ",size=", &call
->virtual_alloc
.size
);
194 dump_uint64( ",zero_bits=", &call
->virtual_alloc
.zero_bits
);
195 fprintf( stderr
, ",op_type=%x,prot=%x", call
->virtual_alloc
.op_type
, call
->virtual_alloc
.prot
);
197 case APC_VIRTUAL_ALLOC_EX
:
198 dump_uint64( "APC_VIRTUAL_ALLOC_EX,addr=", &call
->virtual_alloc_ex
.addr
);
199 dump_uint64( ",size=", &call
->virtual_alloc_ex
.size
);
200 dump_uint64( ",limit_low=", &call
->virtual_alloc_ex
.limit_low
);
201 dump_uint64( ",limit_high=", &call
->virtual_alloc_ex
.limit_high
);
202 dump_uint64( ",align=", &call
->virtual_alloc_ex
.align
);
203 fprintf( stderr
, ",op_type=%x,prot=%x,attributes=%x",
204 call
->virtual_alloc_ex
.op_type
, call
->virtual_alloc_ex
.prot
,
205 call
->virtual_alloc_ex
.attributes
);
207 case APC_VIRTUAL_FREE
:
208 dump_uint64( "APC_VIRTUAL_FREE,addr=", &call
->virtual_free
.addr
);
209 dump_uint64( ",size=", &call
->virtual_free
.size
);
210 fprintf( stderr
, ",op_type=%x", call
->virtual_free
.op_type
);
212 case APC_VIRTUAL_QUERY
:
213 dump_uint64( "APC_VIRTUAL_QUERY,addr=", &call
->virtual_query
.addr
);
215 case APC_VIRTUAL_PROTECT
:
216 dump_uint64( "APC_VIRTUAL_PROTECT,addr=", &call
->virtual_protect
.addr
);
217 dump_uint64( ",size=", &call
->virtual_protect
.size
);
218 fprintf( stderr
, ",prot=%x", call
->virtual_protect
.prot
);
220 case APC_VIRTUAL_FLUSH
:
221 dump_uint64( "APC_VIRTUAL_FLUSH,addr=", &call
->virtual_flush
.addr
);
222 dump_uint64( ",size=", &call
->virtual_flush
.size
);
224 case APC_VIRTUAL_LOCK
:
225 dump_uint64( "APC_VIRTUAL_LOCK,addr=", &call
->virtual_lock
.addr
);
226 dump_uint64( ",size=", &call
->virtual_lock
.size
);
228 case APC_VIRTUAL_UNLOCK
:
229 dump_uint64( "APC_VIRTUAL_UNLOCK,addr=", &call
->virtual_unlock
.addr
);
230 dump_uint64( ",size=", &call
->virtual_unlock
.size
);
233 fprintf( stderr
, "APC_MAP_VIEW,handle=%04x", call
->map_view
.handle
);
234 dump_uint64( ",addr=", &call
->map_view
.addr
);
235 dump_uint64( ",size=", &call
->map_view
.size
);
236 dump_uint64( ",offset=", &call
->map_view
.offset
);
237 dump_uint64( ",zero_bits=", &call
->map_view
.zero_bits
);
238 fprintf( stderr
, ",alloc_type=%x,prot=%x", call
->map_view
.alloc_type
, call
->map_view
.prot
);
240 case APC_MAP_VIEW_EX
:
241 fprintf( stderr
, "APC_MAP_VIEW_EX,handle=%04x", call
->map_view_ex
.handle
);
242 dump_uint64( ",addr=", &call
->map_view_ex
.addr
);
243 dump_uint64( ",size=", &call
->map_view_ex
.size
);
244 dump_uint64( ",offset=", &call
->map_view_ex
.offset
);
245 dump_uint64( ",limit_low=", &call
->map_view_ex
.limit_low
);
246 dump_uint64( ",limit_high=", &call
->map_view_ex
.limit_high
);
247 fprintf( stderr
, ",alloc_type=%x,prot=%x,machine=%04x",
248 call
->map_view_ex
.alloc_type
, call
->map_view_ex
.prot
, call
->map_view_ex
.machine
);
251 dump_uint64( "APC_UNMAP_VIEW,addr=", &call
->unmap_view
.addr
);
253 case APC_CREATE_THREAD
:
254 dump_uint64( "APC_CREATE_THREAD,func=", &call
->create_thread
.func
);
255 dump_uint64( ",arg=", &call
->create_thread
.arg
);
256 dump_uint64( ",zero_bits=", &call
->create_thread
.zero_bits
);
257 dump_uint64( ",reserve=", &call
->create_thread
.reserve
);
258 dump_uint64( ",commit=", &call
->create_thread
.commit
);
259 fprintf( stderr
, ",flags=%x", call
->create_thread
.flags
);
262 fprintf( stderr
, "APC_DUP_HANDLE,src_handle=%04x,dst_process=%04x,access=%x,attributes=%x,options=%x",
263 call
->dup_handle
.src_handle
, call
->dup_handle
.dst_process
, call
->dup_handle
.access
,
264 call
->dup_handle
.attributes
, call
->dup_handle
.options
);
267 fprintf( stderr
, "type=%u", call
->type
);
270 fputc( '}', stderr
);
273 static void dump_apc_result( const char *prefix
, const apc_result_t
*result
)
275 fprintf( stderr
, "%s{", prefix
);
281 fprintf( stderr
, "APC_ASYNC_IO,status=%s,total=%u",
282 get_status_name( result
->async_io
.status
), result
->async_io
.total
);
284 case APC_VIRTUAL_ALLOC
:
285 fprintf( stderr
, "APC_VIRTUAL_ALLOC,status=%s",
286 get_status_name( result
->virtual_alloc
.status
));
287 dump_uint64( ",addr=", &result
->virtual_alloc
.addr
);
288 dump_uint64( ",size=", &result
->virtual_alloc
.size
);
290 case APC_VIRTUAL_FREE
:
291 fprintf( stderr
, "APC_VIRTUAL_FREE,status=%s",
292 get_status_name( result
->virtual_free
.status
));
293 dump_uint64( ",addr=", &result
->virtual_free
.addr
);
294 dump_uint64( ",size=", &result
->virtual_free
.size
);
296 case APC_VIRTUAL_QUERY
:
297 fprintf( stderr
, "APC_VIRTUAL_QUERY,status=%s",
298 get_status_name( result
->virtual_query
.status
));
299 dump_uint64( ",base=", &result
->virtual_query
.base
);
300 dump_uint64( ",alloc_base=", &result
->virtual_query
.alloc_base
);
301 dump_uint64( ",size=", &result
->virtual_query
.size
);
302 fprintf( stderr
, ",state=%x,prot=%x,alloc_prot=%x,alloc_type=%x",
303 result
->virtual_query
.state
, result
->virtual_query
.prot
,
304 result
->virtual_query
.alloc_prot
, result
->virtual_query
.alloc_type
);
306 case APC_VIRTUAL_PROTECT
:
307 fprintf( stderr
, "APC_VIRTUAL_PROTECT,status=%s",
308 get_status_name( result
->virtual_protect
.status
));
309 dump_uint64( ",addr=", &result
->virtual_protect
.addr
);
310 dump_uint64( ",size=", &result
->virtual_protect
.size
);
311 fprintf( stderr
, ",prot=%x", result
->virtual_protect
.prot
);
313 case APC_VIRTUAL_FLUSH
:
314 fprintf( stderr
, "APC_VIRTUAL_FLUSH,status=%s",
315 get_status_name( result
->virtual_flush
.status
));
316 dump_uint64( ",addr=", &result
->virtual_flush
.addr
);
317 dump_uint64( ",size=", &result
->virtual_flush
.size
);
319 case APC_VIRTUAL_LOCK
:
320 fprintf( stderr
, "APC_VIRTUAL_LOCK,status=%s",
321 get_status_name( result
->virtual_lock
.status
));
322 dump_uint64( ",addr=", &result
->virtual_lock
.addr
);
323 dump_uint64( ",size=", &result
->virtual_lock
.size
);
325 case APC_VIRTUAL_UNLOCK
:
326 fprintf( stderr
, "APC_VIRTUAL_UNLOCK,status=%s",
327 get_status_name( result
->virtual_unlock
.status
));
328 dump_uint64( ",addr=", &result
->virtual_unlock
.addr
);
329 dump_uint64( ",size=", &result
->virtual_unlock
.size
);
332 fprintf( stderr
, "APC_MAP_VIEW,status=%s",
333 get_status_name( result
->map_view
.status
));
334 dump_uint64( ",addr=", &result
->map_view
.addr
);
335 dump_uint64( ",size=", &result
->map_view
.size
);
338 fprintf( stderr
, "APC_UNMAP_VIEW,status=%s",
339 get_status_name( result
->unmap_view
.status
) );
341 case APC_CREATE_THREAD
:
342 fprintf( stderr
, "APC_CREATE_THREAD,status=%s,pid=%04x,tid=%04x,handle=%04x",
343 get_status_name( result
->create_thread
.status
),
344 result
->create_thread
.pid
, result
->create_thread
.tid
, result
->create_thread
.handle
);
347 fprintf( stderr
, "APC_DUP_HANDLE,status=%s,handle=%04x",
348 get_status_name( result
->dup_handle
.status
), result
->dup_handle
.handle
);
351 fprintf( stderr
, "type=%u", result
->type
);
354 fputc( '}', stderr
);
357 static void dump_async_data( const char *prefix
, const async_data_t
*data
)
359 fprintf( stderr
, "%s{handle=%04x,event=%04x", prefix
, data
->handle
, data
->event
);
360 dump_uint64( ",iosb=", &data
->iosb
);
361 dump_uint64( ",user=", &data
->user
);
362 dump_uint64( ",apc=", &data
->apc
);
363 dump_uint64( ",apc_context=", &data
->apc_context
);
364 fputc( '}', stderr
);
367 static void dump_irp_params( const char *prefix
, const irp_params_t
*data
)
372 fprintf( stderr
, "%s{NONE}", prefix
);
374 case IRP_CALL_CREATE
:
375 fprintf( stderr
, "%s{CREATE,access=%08x,sharing=%08x,options=%08x",
376 prefix
, data
->create
.access
, data
->create
.sharing
, data
->create
.options
);
377 dump_uint64( ",device=", &data
->create
.device
);
378 fprintf( stderr
, ",file=%08x}", data
->create
.file
);
381 fprintf( stderr
, "%s{CLOSE", prefix
);
382 dump_uint64( ",file=", &data
->close
.file
);
383 fputc( '}', stderr
);
386 fprintf( stderr
, "%s{READ,key=%08x,out_size=%u", prefix
, data
->read
.key
,
387 data
->read
.out_size
);
388 dump_uint64( ",pos=", &data
->read
.pos
);
389 dump_uint64( ",file=", &data
->read
.file
);
390 fputc( '}', stderr
);
393 fprintf( stderr
, "%s{WRITE,key=%08x", prefix
, data
->write
.key
);
394 dump_uint64( ",pos=", &data
->write
.pos
);
395 dump_uint64( ",file=", &data
->write
.file
);
396 fputc( '}', stderr
);
399 fprintf( stderr
, "%s{FLUSH", prefix
);
400 dump_uint64( ",file=", &data
->flush
.file
);
401 fputc( '}', stderr
);
404 fprintf( stderr
, "%s{IOCTL", prefix
);
405 dump_ioctl_code( ",code=", &data
->ioctl
.code
);
406 fprintf( stderr
, ",out_size=%u", data
->ioctl
.out_size
);
407 dump_uint64( ",file=", &data
->ioctl
.file
);
408 fputc( '}', stderr
);
410 case IRP_CALL_VOLUME
:
411 fprintf( stderr
, "%s{VOLUME,class=%u,out_size=%u", prefix
,
412 data
->volume
.info_class
, data
->volume
.out_size
);
413 dump_uint64( ",file=", &data
->volume
.file
);
414 fputc( '}', stderr
);
417 fprintf( stderr
, "%s{FREE", prefix
);
418 dump_uint64( ",obj=", &data
->free
.obj
);
419 fputc( '}', stderr
);
421 case IRP_CALL_CANCEL
:
422 fprintf( stderr
, "%s{CANCEL", prefix
);
423 dump_uint64( ",irp=", &data
->cancel
.irp
);
424 fputc( '}', stderr
);
429 static void dump_hw_input( const char *prefix
, const hw_input_t
*input
)
434 fprintf( stderr
, "%s{type=MOUSE,x=%d,y=%d,data=%08x,flags=%08x,time=%u",
435 prefix
, input
->mouse
.x
, input
->mouse
.y
, input
->mouse
.data
, input
->mouse
.flags
,
437 dump_uint64( ",info=", &input
->mouse
.info
);
438 fputc( '}', stderr
);
441 fprintf( stderr
, "%s{type=KEYBOARD,vkey=%04hx,scan=%04hx,flags=%08x,time=%u",
442 prefix
, input
->kbd
.vkey
, input
->kbd
.scan
, input
->kbd
.flags
, input
->kbd
.time
);
443 dump_uint64( ",info=", &input
->kbd
.info
);
444 fputc( '}', stderr
);
447 fprintf( stderr
, "%s{type=HARDWARE,msg=%04x", prefix
, input
->hw
.msg
);
448 dump_uint64( ",wparam=", &input
->hw
.wparam
);
449 dump_uint64( ",lparam=", &input
->hw
.lparam
);
450 switch (input
->hw
.msg
)
453 fprintf( stderr
, "%s{type=HID,device=%04x,usage=%04x:%04x,count=%u,length=%u}",
454 prefix
, input
->hw
.hid
.device
, HIWORD(input
->hw
.hid
.usage
), LOWORD(input
->hw
.hid
.usage
),
455 input
->hw
.hid
.count
, input
->hw
.hid
.length
);
457 case WM_INPUT_DEVICE_CHANGE
:
458 fprintf( stderr
, "%s{type=HID,device=%04x,usage=%04x:%04x}",
459 prefix
, input
->hw
.hid
.device
, HIWORD(input
->hw
.hid
.usage
), LOWORD(input
->hw
.hid
.usage
) );
462 fputc( '}', stderr
);
465 fprintf( stderr
, "%s{type=%04x}", prefix
, input
->type
);
470 static void dump_obj_locator( const char *prefix
, const obj_locator_t
*locator
)
472 fprintf( stderr
, "%s{", prefix
);
473 dump_uint64( "id=", &locator
->id
);
474 dump_uint64( ",offset=", &locator
->offset
);
475 fprintf( stderr
, "}" );
478 static void dump_luid( const char *prefix
, const struct luid
*luid
)
480 fprintf( stderr
, "%s%d.%u", prefix
, luid
->high_part
, luid
->low_part
);
483 static void dump_generic_map( const char *prefix
, const generic_map_t
*map
)
485 fprintf( stderr
, "%s{r=%08x,w=%08x,x=%08x,a=%08x}",
486 prefix
, map
->read
, map
->write
, map
->exec
, map
->all
);
489 static void dump_varargs_ints( const char *prefix
, data_size_t size
)
491 const int *data
= cur_data
;
492 data_size_t len
= size
/ sizeof(*data
);
494 fprintf( stderr
,"%s{", prefix
);
497 fprintf( stderr
, "%d", *data
++ );
498 if (--len
) fputc( ',', stderr
);
500 fputc( '}', stderr
);
504 static void dump_varargs_uints( const char *prefix
, data_size_t size
)
506 const unsigned int *data
= cur_data
;
508 dump_uints( prefix
, data
, size
/ sizeof(*data
) );
512 static void dump_varargs_uints64( const char *prefix
, data_size_t size
)
514 const unsigned __int64
*data
= cur_data
;
516 dump_uints64( prefix
, data
, size
/ sizeof(*data
) );
520 static void dump_varargs_ushorts( const char *prefix
, data_size_t size
)
522 const unsigned short *data
= cur_data
;
523 data_size_t len
= size
/ sizeof(*data
);
525 fprintf( stderr
, "%s{", prefix
);
528 fprintf( stderr
, "%04x", *data
++ );
529 if (--len
) fputc( ',', stderr
);
531 fputc( '}', stderr
);
535 static void dump_varargs_apc_call( const char *prefix
, data_size_t size
)
537 const apc_call_t
*call
= cur_data
;
539 if (size
>= sizeof(*call
))
541 dump_apc_call( prefix
, call
);
542 size
= sizeof(*call
);
544 else fprintf( stderr
, "%s{}", prefix
);
548 static void dump_varargs_apc_result( const char *prefix
, data_size_t size
)
550 const apc_result_t
*result
= cur_data
;
552 if (size
>= sizeof(*result
))
554 dump_apc_result( prefix
, result
);
555 size
= sizeof(*result
);
560 static void dump_varargs_select_op( const char *prefix
, data_size_t size
)
566 fprintf( stderr
, "%s{}", prefix
);
569 memset( &data
, 0, sizeof(data
) );
570 memcpy( &data
, cur_data
, min( size
, sizeof(data
) ));
572 fprintf( stderr
, "%s{", prefix
);
576 fprintf( stderr
, "NONE" );
579 case SELECT_WAIT_ALL
:
580 fprintf( stderr
, "%s", data
.op
== SELECT_WAIT
? "WAIT" : "WAIT_ALL" );
581 if (size
> offsetof( select_op_t
, wait
.handles
))
582 dump_handles( ",handles=", data
.wait
.handles
,
583 min( size
, sizeof(data
.wait
) ) - offsetof( select_op_t
, wait
.handles
));
585 case SELECT_SIGNAL_AND_WAIT
:
586 fprintf( stderr
, "SIGNAL_AND_WAIT,signal=%04x,wait=%04x",
587 data
.signal_and_wait
.signal
, data
.signal_and_wait
.wait
);
589 case SELECT_KEYED_EVENT_WAIT
:
590 case SELECT_KEYED_EVENT_RELEASE
:
591 fprintf( stderr
, "KEYED_EVENT_%s,handle=%04x",
592 data
.op
== SELECT_KEYED_EVENT_WAIT
? "WAIT" : "RELEASE",
593 data
.keyed_event
.handle
);
594 dump_uint64( ",key=", &data
.keyed_event
.key
);
597 fprintf( stderr
, "op=%u", data
.op
);
600 fputc( '}', stderr
);
604 static void dump_varargs_user_handles( const char *prefix
, data_size_t size
)
606 const user_handle_t
*data
= cur_data
;
607 data_size_t len
= size
/ sizeof(*data
);
609 fprintf( stderr
,"%s{", prefix
);
612 fprintf( stderr
, "%08x", *data
++ );
613 if (--len
) fputc( ',', stderr
);
615 fputc( '}', stderr
);
619 static void dump_varargs_bytes( const char *prefix
, data_size_t size
)
621 const unsigned char *data
= cur_data
;
622 data_size_t len
= min( 1024, size
);
624 fprintf( stderr
,"%s{", prefix
);
627 fprintf( stderr
, "%02x", *data
++ );
628 if (--len
) fputc( ',', stderr
);
630 if (size
> 1024) fprintf( stderr
, "...(total %u)", size
);
631 fputc( '}', stderr
);
635 static void dump_varargs_string( const char *prefix
, data_size_t size
)
637 fprintf( stderr
, "%s\"%.*s\"", prefix
, (int)size
, (const char *)cur_data
);
641 static void dump_varargs_unicode_str( const char *prefix
, data_size_t size
)
643 fprintf( stderr
, "%sL\"", prefix
);
644 dump_strW( cur_data
, size
, stderr
, "\"\"" );
645 fputc( '\"', stderr
);
649 static void dump_varargs_context( const char *prefix
, data_size_t size
)
651 const context_t
*context
= cur_data
;
657 fprintf( stderr
, "%s{}", prefix
);
660 size
= min( size
, sizeof(ctx
) );
661 memset( &ctx
, 0, sizeof(ctx
) );
662 memcpy( &ctx
, context
, size
);
666 case IMAGE_FILE_MACHINE_I386
:
667 fprintf( stderr
, "%s{machine=i386", prefix
);
668 if (ctx
.flags
& SERVER_CTX_CONTROL
)
669 fprintf( stderr
, ",eip=%08x,esp=%08x,ebp=%08x,eflags=%08x,cs=%04x,ss=%04x",
670 ctx
.ctl
.i386_regs
.eip
, ctx
.ctl
.i386_regs
.esp
, ctx
.ctl
.i386_regs
.ebp
,
671 ctx
.ctl
.i386_regs
.eflags
, ctx
.ctl
.i386_regs
.cs
, ctx
.ctl
.i386_regs
.ss
);
672 if (ctx
.flags
& SERVER_CTX_SEGMENTS
)
673 fprintf( stderr
, ",ds=%04x,es=%04x,fs=%04x,gs=%04x",
674 ctx
.seg
.i386_regs
.ds
, ctx
.seg
.i386_regs
.es
,
675 ctx
.seg
.i386_regs
.fs
, ctx
.seg
.i386_regs
.gs
);
676 if (ctx
.flags
& SERVER_CTX_INTEGER
)
677 fprintf( stderr
, ",eax=%08x,ebx=%08x,ecx=%08x,edx=%08x,esi=%08x,edi=%08x",
678 ctx
.integer
.i386_regs
.eax
, ctx
.integer
.i386_regs
.ebx
, ctx
.integer
.i386_regs
.ecx
,
679 ctx
.integer
.i386_regs
.edx
, ctx
.integer
.i386_regs
.esi
, ctx
.integer
.i386_regs
.edi
);
680 if (ctx
.flags
& SERVER_CTX_DEBUG_REGISTERS
)
681 fprintf( stderr
, ",dr0=%08x,dr1=%08x,dr2=%08x,dr3=%08x,dr6=%08x,dr7=%08x",
682 ctx
.debug
.i386_regs
.dr0
, ctx
.debug
.i386_regs
.dr1
, ctx
.debug
.i386_regs
.dr2
,
683 ctx
.debug
.i386_regs
.dr3
, ctx
.debug
.i386_regs
.dr6
, ctx
.debug
.i386_regs
.dr7
);
684 if (ctx
.flags
& SERVER_CTX_FLOATING_POINT
)
686 fprintf( stderr
, ",fp.ctrl=%08x,fp.status=%08x,fp.tag=%08x,fp.err_off=%08x,fp.err_sel=%08x",
687 ctx
.fp
.i386_regs
.ctrl
, ctx
.fp
.i386_regs
.status
, ctx
.fp
.i386_regs
.tag
,
688 ctx
.fp
.i386_regs
.err_off
, ctx
.fp
.i386_regs
.err_sel
);
689 fprintf( stderr
, ",fp.data_off=%08x,fp.data_sel=%08x,fp.cr0npx=%08x",
690 ctx
.fp
.i386_regs
.data_off
, ctx
.fp
.i386_regs
.data_sel
, ctx
.fp
.i386_regs
.cr0npx
);
691 for (i
= 0; i
< 8; i
++)
693 unsigned __int64 reg
[2];
694 memset( reg
, 0, sizeof(reg
) );
695 memcpy( reg
, &ctx
.fp
.i386_regs
.regs
[10 * i
], 10 );
696 fprintf( stderr
, ",fp.reg%u=", i
);
697 dump_uint128( "", reg
);
700 if (ctx
.flags
& SERVER_CTX_EXTENDED_REGISTERS
)
701 dump_uints( ",extended=", (const unsigned int *)ctx
.ext
.i386_regs
,
702 sizeof(ctx
.ext
.i386_regs
) / sizeof(int) );
703 if (ctx
.flags
& SERVER_CTX_YMM_REGISTERS
)
704 for (i
= 0; i
< 16; i
++)
706 fprintf( stderr
, ",ymm%u=", i
);
707 dump_uint128( "", (const unsigned __int64
*)&ctx
.ymm
.regs
.ymm_high
[i
] );
710 case IMAGE_FILE_MACHINE_AMD64
:
711 fprintf( stderr
, "%s{machine=x86_64", prefix
);
712 if (ctx
.flags
& SERVER_CTX_CONTROL
)
714 dump_uint64( ",rip=", &ctx
.ctl
.x86_64_regs
.rip
);
715 dump_uint64( ",rbp=", &ctx
.ctl
.x86_64_regs
.rbp
);
716 dump_uint64( ",rsp=", &ctx
.ctl
.x86_64_regs
.rsp
);
717 fprintf( stderr
, ",cs=%04x,ss=%04x,flags=%08x",
718 ctx
.ctl
.x86_64_regs
.cs
, ctx
.ctl
.x86_64_regs
.ss
, ctx
.ctl
.x86_64_regs
.flags
);
720 if (ctx
.flags
& SERVER_CTX_INTEGER
)
722 dump_uint64( ",rax=", &ctx
.integer
.x86_64_regs
.rax
);
723 dump_uint64( ",rbx=", &ctx
.integer
.x86_64_regs
.rbx
);
724 dump_uint64( ",rcx=", &ctx
.integer
.x86_64_regs
.rcx
);
725 dump_uint64( ",rdx=", &ctx
.integer
.x86_64_regs
.rdx
);
726 dump_uint64( ",rsi=", &ctx
.integer
.x86_64_regs
.rsi
);
727 dump_uint64( ",rdi=", &ctx
.integer
.x86_64_regs
.rdi
);
728 dump_uint64( ",r8=", &ctx
.integer
.x86_64_regs
.r8
);
729 dump_uint64( ",r9=", &ctx
.integer
.x86_64_regs
.r9
);
730 dump_uint64( ",r10=", &ctx
.integer
.x86_64_regs
.r10
);
731 dump_uint64( ",r11=", &ctx
.integer
.x86_64_regs
.r11
);
732 dump_uint64( ",r12=", &ctx
.integer
.x86_64_regs
.r12
);
733 dump_uint64( ",r13=", &ctx
.integer
.x86_64_regs
.r13
);
734 dump_uint64( ",r14=", &ctx
.integer
.x86_64_regs
.r14
);
735 dump_uint64( ",r15=", &ctx
.integer
.x86_64_regs
.r15
);
737 if (ctx
.flags
& SERVER_CTX_SEGMENTS
)
738 fprintf( stderr
, ",ds=%04x,es=%04x,fs=%04x,gs=%04x",
739 ctx
.seg
.x86_64_regs
.ds
, ctx
.seg
.x86_64_regs
.es
,
740 ctx
.seg
.x86_64_regs
.fs
, ctx
.seg
.x86_64_regs
.gs
);
741 if (ctx
.flags
& SERVER_CTX_DEBUG_REGISTERS
)
743 dump_uint64( ",dr0=", &ctx
.debug
.x86_64_regs
.dr0
);
744 dump_uint64( ",dr1=", &ctx
.debug
.x86_64_regs
.dr1
);
745 dump_uint64( ",dr2=", &ctx
.debug
.x86_64_regs
.dr2
);
746 dump_uint64( ",dr3=", &ctx
.debug
.x86_64_regs
.dr3
);
747 dump_uint64( ",dr6=", &ctx
.debug
.x86_64_regs
.dr6
);
748 dump_uint64( ",dr7=", &ctx
.debug
.x86_64_regs
.dr7
);
750 if (ctx
.flags
& SERVER_CTX_FLOATING_POINT
)
751 for (i
= 0; i
< 32; i
++)
753 fprintf( stderr
, ",fp%u=", i
);
754 dump_uint128( "", (const unsigned __int64
*)&ctx
.fp
.x86_64_regs
.fpregs
[i
] );
756 if (ctx
.flags
& SERVER_CTX_YMM_REGISTERS
)
757 for (i
= 0; i
< 16; i
++)
759 fprintf( stderr
, ",ymm%u=", i
);
760 dump_uint128( "", (const unsigned __int64
*)&ctx
.ymm
.regs
.ymm_high
[i
] );
763 case IMAGE_FILE_MACHINE_ARMNT
:
764 fprintf( stderr
, "%s{machine=arm", prefix
);
765 if (ctx
.flags
& SERVER_CTX_CONTROL
)
766 fprintf( stderr
, ",sp=%08x,lr=%08x,pc=%08x,cpsr=%08x",
767 ctx
.ctl
.arm_regs
.sp
, ctx
.ctl
.arm_regs
.lr
,
768 ctx
.ctl
.arm_regs
.pc
, ctx
.ctl
.arm_regs
.cpsr
);
769 if (ctx
.flags
& SERVER_CTX_INTEGER
)
770 for (i
= 0; i
< 13; i
++) fprintf( stderr
, ",r%u=%08x", i
, ctx
.integer
.arm_regs
.r
[i
] );
771 if (ctx
.flags
& SERVER_CTX_DEBUG_REGISTERS
)
773 for (i
= 0; i
< 8; i
++)
774 fprintf( stderr
, ",bcr%u=%08x,bvr%u=%08x",
775 i
, ctx
.debug
.arm_regs
.bcr
[i
], i
, ctx
.debug
.arm_regs
.bvr
[i
] );
776 fprintf( stderr
, ",wcr0=%08x,wvr0=%08x",
777 ctx
.debug
.arm_regs
.wcr
[0], ctx
.debug
.arm_regs
.wvr
[0] );
779 if (ctx
.flags
& SERVER_CTX_FLOATING_POINT
)
781 for (i
= 0; i
< 32; i
++)
783 fprintf( stderr
, ",d%u=", i
);
784 dump_uint64( "", &ctx
.fp
.arm_regs
.d
[i
] );
786 fprintf( stderr
, ",fpscr=%08x", ctx
.fp
.arm_regs
.fpscr
);
789 case IMAGE_FILE_MACHINE_ARM64
:
790 fprintf( stderr
, "%s{machine=arm64", prefix
);
791 if (ctx
.flags
& SERVER_CTX_CONTROL
)
793 dump_uint64( ",sp=", &ctx
.ctl
.arm64_regs
.sp
);
794 dump_uint64( ",pc=", &ctx
.ctl
.arm64_regs
.pc
);
795 dump_uint64( ",pstate=", &ctx
.ctl
.arm64_regs
.pstate
);
797 if (ctx
.flags
& SERVER_CTX_INTEGER
)
799 for (i
= 0; i
< 31; i
++)
801 fprintf( stderr
, ",x%u=", i
);
802 dump_uint64( "", &ctx
.integer
.arm64_regs
.x
[i
] );
805 if (ctx
.flags
& SERVER_CTX_DEBUG_REGISTERS
)
807 for (i
= 0; i
< 8; i
++)
809 fprintf( stderr
, ",bcr%u=%08x,bvr%u=", i
, ctx
.debug
.arm64_regs
.bcr
[i
], i
);
810 dump_uint64( "", &ctx
.debug
.arm64_regs
.bvr
[i
] );
812 for (i
= 0; i
< 2; i
++)
814 fprintf( stderr
, ",wcr%u=%08x,wvr%u=", i
, ctx
.debug
.arm64_regs
.wcr
[i
], i
);
815 dump_uint64( "", &ctx
.debug
.arm64_regs
.wvr
[i
] );
818 if (ctx
.flags
& SERVER_CTX_FLOATING_POINT
)
820 for (i
= 0; i
< 32; i
++)
822 fprintf( stderr
, ",q%u=", i
);
823 dump_uint64( "", &ctx
.fp
.arm64_regs
.q
[i
].high
);
824 dump_uint64( "", &ctx
.fp
.arm64_regs
.q
[i
].low
);
826 fprintf( stderr
, ",fpcr=%08x,fpsr=%08x", ctx
.fp
.arm64_regs
.fpcr
, ctx
.fp
.arm64_regs
.fpsr
);
830 fprintf( stderr
, "%s{machine=%04x", prefix
, ctx
.machine
);
833 if (ctx
.flags
& SERVER_CTX_EXEC_SPACE
)
837 switch (ctx
.exec_space
.space
.space
)
839 case EXEC_SPACE_USERMODE
: space
= "user"; break;
840 case EXEC_SPACE_SYSCALL
: space
= "syscall"; break;
841 case EXEC_SPACE_EXCEPTION
: space
= "exception"; break;
842 default: space
= "invalid"; break;
844 fprintf( stderr
, ",exec_space=%s", space
);
846 fputc( '}', stderr
);
850 static void dump_varargs_contexts( const char *prefix
, data_size_t size
)
854 fprintf( stderr
, "%s{}", prefix
);
857 fprintf( stderr
, "%s{", prefix
);
860 dump_varargs_context( "", cur_size
);
861 fputc( cur_size
? ',' : '}', stderr
);
865 static void dump_varargs_debug_event( const char *prefix
, data_size_t size
)
871 fprintf( stderr
, "%s{}", prefix
);
874 size
= min( size
, sizeof(event
) );
875 memset( &event
, 0, sizeof(event
) );
876 memcpy( &event
, cur_data
, size
);
881 fprintf( stderr
, "%s{idle}", prefix
);
883 case DbgReplyPending
:
884 fprintf( stderr
, "%s{pending}", prefix
);
886 case DbgCreateThreadStateChange
:
887 fprintf( stderr
, "%s{create_thread,thread=%04x", prefix
, event
.create_thread
.handle
);
888 dump_uint64( ",start=", &event
.create_thread
.start
);
889 fputc( '}', stderr
);
891 case DbgCreateProcessStateChange
:
892 fprintf( stderr
, "%s{create_process,file=%04x,process=%04x,thread=%04x", prefix
,
893 event
.create_process
.file
, event
.create_process
.process
,
894 event
.create_process
.thread
);
895 dump_uint64( ",base=", &event
.create_process
.base
);
896 fprintf( stderr
, ",offset=%d,size=%d",
897 event
.create_process
.dbg_offset
, event
.create_process
.dbg_size
);
898 dump_uint64( ",start=", &event
.create_process
.start
);
899 fputc( '}', stderr
);
901 case DbgExitThreadStateChange
:
902 fprintf( stderr
, "%s{exit_thread,code=%d}", prefix
, event
.exit
.exit_code
);
904 case DbgExitProcessStateChange
:
905 fprintf( stderr
, "%s{exit_process,code=%d}", prefix
, event
.exit
.exit_code
);
907 case DbgExceptionStateChange
:
908 case DbgBreakpointStateChange
:
909 case DbgSingleStepStateChange
:
910 fprintf( stderr
, "%s{%s,first=%d,exc_code=%08x,flags=%08x", prefix
,
911 event
.code
== DbgBreakpointStateChange
? "breakpoint" :
912 event
.code
== DbgSingleStepStateChange
? "singlestep" : "exception",
913 event
.exception
.first
, event
.exception
.exc_code
, event
.exception
.flags
);
914 dump_uint64( ",record=", &event
.exception
.record
);
915 dump_uint64( ",address=", &event
.exception
.address
);
916 event
.exception
.nb_params
= min( event
.exception
.nb_params
, EXCEPTION_MAXIMUM_PARAMETERS
);
917 dump_uints64( ",params=", event
.exception
.params
, event
.exception
.nb_params
);
918 fputc( '}', stderr
);
920 case DbgLoadDllStateChange
:
921 fprintf( stderr
, "%s{load_dll,file=%04x", prefix
, event
.load_dll
.handle
);
922 dump_uint64( ",base=", &event
.load_dll
.base
);
923 fprintf( stderr
, ",offset=%d,size=%d",
924 event
.load_dll
.dbg_offset
, event
.load_dll
.dbg_size
);
925 dump_uint64( ",name=", &event
.load_dll
.name
);
926 fputc( '}', stderr
);
928 case DbgUnloadDllStateChange
:
929 fprintf( stderr
, "%s{unload_dll", prefix
);
930 dump_uint64( ",base=", &event
.unload_dll
.base
);
931 fputc( '}', stderr
);
934 fprintf( stderr
, "%s{code=??? (%d)}", prefix
, event
.code
);
940 /* dump a unicode string contained in a buffer; helper for dump_varargs_startup_info */
941 static data_size_t
dump_inline_unicode_string( const char *prefix
, data_size_t pos
, data_size_t len
, data_size_t total_size
)
943 fputs( prefix
, stderr
);
944 if (pos
>= total_size
) return pos
;
945 if (len
> total_size
- pos
) len
= total_size
- pos
;
946 dump_strW( (const WCHAR
*)cur_data
+ pos
/sizeof(WCHAR
), len
, stderr
, "\"\"" );
947 return pos
+ (len
/ sizeof(WCHAR
)) * sizeof(WCHAR
);
950 static void dump_varargs_startup_info( const char *prefix
, data_size_t size
)
953 data_size_t pos
= sizeof(info
);
955 memset( &info
, 0, sizeof(info
) );
956 memcpy( &info
, cur_data
, min( size
, sizeof(info
) ));
959 "%s{debug_flags=%x,console_flags=%x,console=%04x,hstdin=%04x,hstdout=%04x,hstderr=%04x,"
960 "x=%u,y=%u,xsize=%u,ysize=%u,xchars=%u,ychars=%u,attribute=%02x,flags=%x,show=%u,"
961 "process_group_id=%u",
962 prefix
, info
.debug_flags
, info
.console_flags
, info
.console
,
963 info
.hstdin
, info
.hstdout
, info
.hstderr
, info
.x
, info
.y
, info
.xsize
, info
.ysize
,
964 info
.xchars
, info
.ychars
, info
.attribute
, info
.flags
, info
.show
, info
.process_group_id
);
965 pos
= dump_inline_unicode_string( ",curdir=L\"", pos
, info
.curdir_len
, size
);
966 pos
= dump_inline_unicode_string( "\",dllpath=L\"", pos
, info
.dllpath_len
, size
);
967 pos
= dump_inline_unicode_string( "\",imagepath=L\"", pos
, info
.imagepath_len
, size
);
968 pos
= dump_inline_unicode_string( "\",cmdline=L\"", pos
, info
.cmdline_len
, size
);
969 pos
= dump_inline_unicode_string( "\",title=L\"", pos
, info
.title_len
, size
);
970 pos
= dump_inline_unicode_string( "\",desktop=L\"", pos
, info
.desktop_len
, size
);
971 pos
= dump_inline_unicode_string( "\",shellinfo=L\"", pos
, info
.shellinfo_len
, size
);
972 pos
= dump_inline_unicode_string( "\",runtime=L\"", pos
, info
.runtime_len
, size
);
973 fprintf( stderr
, "\"}" );
977 static void dump_varargs_rectangles( const char *prefix
, data_size_t size
)
979 const rectangle_t
*rect
= cur_data
;
980 data_size_t len
= size
/ sizeof(*rect
);
982 fprintf( stderr
,"%s{", prefix
);
985 dump_rectangle( "", rect
++ );
986 if (--len
) fputc( ',', stderr
);
988 fputc( '}', stderr
);
992 static void dump_varargs_cursor_positions( const char *prefix
, data_size_t size
)
994 const cursor_pos_t
*pos
= cur_data
;
995 data_size_t len
= size
/ sizeof(*pos
);
997 fprintf( stderr
, "%s{", prefix
);
1000 fprintf( stderr
, "{x=%d,y=%d,time=%u", pos
->x
, pos
->y
, pos
->time
);
1001 dump_uint64( ",info=", &pos
->info
);
1002 fputc( '}', stderr
);
1004 if (--len
) fputc( ',', stderr
);
1006 fputc( '}', stderr
);
1007 remove_data( size
);
1010 static void dump_varargs_message_data( const char *prefix
, data_size_t size
)
1012 /* FIXME: dump the structured data */
1013 dump_varargs_bytes( prefix
, size
);
1016 static void dump_varargs_properties( const char *prefix
, data_size_t size
)
1018 const property_data_t
*prop
= cur_data
;
1019 data_size_t len
= size
/ sizeof(*prop
);
1021 fprintf( stderr
,"%s{", prefix
);
1024 fprintf( stderr
, "{atom=%04x,str=%d", prop
->atom
, prop
->string
);
1025 dump_uint64( ",data=", &prop
->data
);
1026 fputc( '}', stderr
);
1028 if (--len
) fputc( ',', stderr
);
1030 fputc( '}', stderr
);
1031 remove_data( size
);
1034 static void dump_varargs_luid_attr( const char *prefix
, data_size_t size
)
1036 const struct luid_attr
*lat
= cur_data
;
1037 data_size_t len
= size
/ sizeof(*lat
);
1039 fprintf( stderr
,"%s{", prefix
);
1042 fprintf( stderr
, "{luid=%08x%08x,attrs=%x}", lat
->luid
.high_part
, lat
->luid
.low_part
, lat
->attrs
);
1044 if (--len
) fputc( ',', stderr
);
1046 fputc( '}', stderr
);
1047 remove_data( size
);
1050 static void dump_inline_sid( const char *prefix
, const struct sid
*sid
, data_size_t size
)
1054 fprintf( stderr
,"%s", prefix
);
1055 if (sid_valid_size( sid
, size
))
1057 fprintf( stderr
, "S-%u-%u", sid
->revision
,
1058 ((unsigned int)sid
->id_auth
[2] << 24) |
1059 ((unsigned int)sid
->id_auth
[3] << 16) |
1060 ((unsigned int)sid
->id_auth
[4] << 8) |
1061 ((unsigned int)sid
->id_auth
[5]) );
1062 for (i
= 0; i
< sid
->sub_count
; i
++) fprintf( stderr
, "-%u", sid
->sub_auth
[i
] );
1064 else fprintf( stderr
, "<invalid>" );
1067 static void dump_varargs_sid( const char *prefix
, data_size_t size
)
1069 const struct sid
*sid
= cur_data
;
1070 if (size
) dump_inline_sid( prefix
, sid
, size
);
1071 remove_data( size
);
1074 static void dump_varargs_sids( const char *prefix
, data_size_t size
)
1076 const struct sid
*sid
= cur_data
;
1077 data_size_t len
= size
;
1079 fprintf( stderr
,"%s{", prefix
);
1082 if (!sid_valid_size( sid
, len
))
1084 fprintf( stderr
, "bad len %u", len
);
1087 dump_inline_sid( "", sid
, size
);
1088 len
-= sid_len( sid
);
1089 sid
= (const struct sid
*)((const char *)sid
+ sid_len( sid
));
1090 if (len
) fputc( ',', stderr
);
1092 fputc( '}', stderr
);
1093 remove_data( size
);
1096 static void dump_inline_acl( const char *prefix
, const struct acl
*acl
, data_size_t size
)
1098 const struct ace
*ace
;
1101 fprintf( stderr
,"%s{", prefix
);
1104 if (size
< sizeof(*acl
))
1106 fprintf( stderr
, "<invalid acl>}" );
1109 size
-= sizeof(*acl
);
1110 for (i
= 0, ace
= ace_first( acl
); i
< acl
->count
; i
++, ace
= ace_next( ace
))
1112 const struct sid
*sid
= (const struct sid
*)(ace
+ 1);
1113 data_size_t sid_size
;
1115 if (size
< sizeof(*ace
) || size
< ace
->size
) break;
1117 sid_size
= ace
->size
- sizeof(*ace
);
1118 if (i
!= 0) fputc( ',', stderr
);
1119 fprintf( stderr
, "{type=" );
1122 case ACCESS_DENIED_ACE_TYPE
: fprintf( stderr
, "ACCESS_DENIED" ); break;
1123 case ACCESS_ALLOWED_ACE_TYPE
: fprintf( stderr
, "ACCESS_ALLOWED" ); break;
1124 case SYSTEM_AUDIT_ACE_TYPE
: fprintf( stderr
, "SYSTEM_AUDIT" ); break;
1125 case SYSTEM_ALARM_ACE_TYPE
: fprintf( stderr
, "SYSTEM_ALARM" ); break;
1126 case SYSTEM_MANDATORY_LABEL_ACE_TYPE
: fprintf( stderr
, "SYSTEM_MANDATORY_LABEL" ); break;
1128 fprintf( stderr
, "%02x", ace
->type
);
1132 fprintf( stderr
, ",flags=%x,mask=%x", ace
->flags
, ace
->mask
);
1133 if (sid
) dump_inline_sid( ",sid=", sid
, sid_size
);
1134 fputc( '}', stderr
);
1137 fputc( '}', stderr
);
1140 static void dump_varargs_acl( const char *prefix
, data_size_t size
)
1142 const struct acl
*acl
= cur_data
;
1143 dump_inline_acl( prefix
, acl
, size
);
1144 remove_data( size
);
1147 static void dump_inline_security_descriptor( const char *prefix
, const struct security_descriptor
*sd
, data_size_t size
)
1149 fprintf( stderr
,"%s{", prefix
);
1150 if (size
>= sizeof(struct security_descriptor
))
1152 size_t offset
= sizeof(struct security_descriptor
);
1153 fprintf( stderr
, "control=%08x", sd
->control
);
1154 if ((sd
->owner_len
> offsetof(struct sid
, sub_auth
[255])) || (offset
+ sd
->owner_len
> size
))
1157 dump_inline_sid( ",owner=", (const struct sid
*)((const char *)sd
+ offset
), sd
->owner_len
);
1159 fprintf( stderr
, ",owner=<not present>" );
1160 offset
+= sd
->owner_len
;
1161 if ((sd
->group_len
> offsetof(struct sid
, sub_auth
[255])) || (offset
+ sd
->group_len
> size
))
1164 dump_inline_sid( ",group=", (const struct sid
*)((const char *)sd
+ offset
), sd
->group_len
);
1166 fprintf( stderr
, ",group=<not present>" );
1167 offset
+= sd
->group_len
;
1168 if ((sd
->sacl_len
>= MAX_ACL_LEN
) || (offset
+ sd
->sacl_len
> size
))
1170 dump_inline_acl( ",sacl=", (const struct acl
*)((const char *)sd
+ offset
), sd
->sacl_len
);
1171 offset
+= sd
->sacl_len
;
1172 if ((sd
->dacl_len
>= MAX_ACL_LEN
) || (offset
+ sd
->dacl_len
> size
))
1174 dump_inline_acl( ",dacl=", (const struct acl
*)((const char *)sd
+ offset
), sd
->dacl_len
);
1175 offset
+= sd
->dacl_len
;
1177 fputc( '}', stderr
);
1180 static void dump_varargs_security_descriptor( const char *prefix
, data_size_t size
)
1182 const struct security_descriptor
*sd
= cur_data
;
1183 dump_inline_security_descriptor( prefix
, sd
, size
);
1184 remove_data( size
);
1187 static void dump_varargs_process_info( const char *prefix
, data_size_t size
)
1189 data_size_t pos
= 0;
1192 fprintf( stderr
,"%s{", prefix
);
1194 while (size
- pos
>= sizeof(struct process_info
))
1196 const struct process_info
*process
;
1197 pos
= (pos
+ 7) & ~7;
1198 process
= (const struct process_info
*)((const char *)cur_data
+ pos
);
1199 if (size
- pos
< sizeof(*process
)) break;
1200 if (pos
) fputc( ',', stderr
);
1201 dump_timeout( "{start_time=", &process
->start_time
);
1202 fprintf( stderr
, ",thread_count=%u,priority=%d,pid=%04x,parent_pid=%04x,session_id=%08x,handle_count=%u,unix_pid=%d,",
1203 process
->thread_count
, process
->priority
, process
->pid
,
1204 process
->parent_pid
, process
->session_id
, process
->handle_count
, process
->unix_pid
);
1205 pos
+= sizeof(*process
);
1207 pos
= dump_inline_unicode_string( "name=L\"", pos
, process
->name_len
, size
);
1209 pos
= (pos
+ 7) & ~7;
1210 fprintf( stderr
, "\",threads={" );
1211 for (i
= 0; i
< process
->thread_count
; i
++)
1213 const struct thread_info
*thread
= (const struct thread_info
*)((const char *)cur_data
+ pos
);
1214 if (size
- pos
< sizeof(*thread
)) break;
1215 if (i
) fputc( ',', stderr
);
1216 dump_timeout( "{start_time=", &thread
->start_time
);
1217 fprintf( stderr
, ",tid=%04x,base_priority=%d,current_priority=%d,unix_tid=%d}",
1218 thread
->tid
, thread
->base_priority
, thread
->current_priority
, thread
->unix_tid
);
1219 pos
+= sizeof(*thread
);
1221 fprintf( stderr
, "}}" );
1223 fputc( '}', stderr
);
1224 remove_data( size
);
1227 static void dump_varargs_object_attributes( const char *prefix
, data_size_t size
)
1229 const struct object_attributes
*objattr
= cur_data
;
1231 fprintf( stderr
,"%s{", prefix
);
1236 if (size
< sizeof(*objattr
) ||
1237 (size
- sizeof(*objattr
) < objattr
->sd_len
) ||
1238 (size
- sizeof(*objattr
) - objattr
->sd_len
< objattr
->name_len
))
1240 fprintf( stderr
, "***invalid***}" );
1241 remove_data( size
);
1245 fprintf( stderr
, "rootdir=%04x,attributes=%08x", objattr
->rootdir
, objattr
->attributes
);
1246 dump_inline_security_descriptor( ",sd=", (const struct security_descriptor
*)(objattr
+ 1), objattr
->sd_len
);
1247 str
= (const WCHAR
*)objattr
+ (sizeof(*objattr
) + objattr
->sd_len
) / sizeof(WCHAR
);
1248 fprintf( stderr
, ",name=L\"" );
1249 dump_strW( str
, objattr
->name_len
, stderr
, "\"\"" );
1250 fputc( '\"', stderr
);
1251 remove_data( (sizeof(*objattr
) + (objattr
->sd_len
& ~1) + (objattr
->name_len
& ~1) + 3) & ~3 );
1253 fputc( '}', stderr
);
1256 static void dump_varargs_object_type_info( const char *prefix
, data_size_t size
)
1258 const struct object_type_info
*info
= cur_data
;
1260 fprintf( stderr
,"%s{", prefix
);
1263 if (size
< sizeof(*info
) || (size
- sizeof(*info
) < info
->name_len
))
1265 fprintf( stderr
, "***invalid***}" );
1266 remove_data( size
);
1270 fprintf( stderr
, "index=%u,obj_count=%u,handle_count=%u,obj_max=%u,handle_max=%u,valid=%08x",
1271 info
->index
,info
->obj_count
, info
->handle_count
, info
->obj_max
, info
->handle_max
,
1272 info
->valid_access
);
1273 dump_generic_map( ",access=", &info
->mapping
);
1274 fprintf( stderr
, ",name=L\"" );
1275 dump_strW( (const WCHAR
*)(info
+ 1), info
->name_len
, stderr
, "\"\"" );
1276 fputc( '\"', stderr
);
1277 remove_data( min( size
, sizeof(*info
) + ((info
->name_len
+ 2) & ~3 )));
1279 fputc( '}', stderr
);
1282 static void dump_varargs_object_types_info( const char *prefix
, data_size_t size
)
1284 fprintf( stderr
,"%s{", prefix
);
1285 while (cur_size
) dump_varargs_object_type_info( ",", cur_size
);
1286 fputc( '}', stderr
);
1289 static void dump_varargs_filesystem_event( const char *prefix
, data_size_t size
)
1291 static const char * const actions
[] = {
1303 fprintf( stderr
,"%s{", prefix
);
1306 const struct filesystem_event
*event
= cur_data
;
1307 data_size_t len
= (offsetof( struct filesystem_event
, name
[event
->len
] ) + sizeof(int)-1)
1308 / sizeof(int) * sizeof(int);
1309 if (size
< len
) break;
1310 if (event
->action
< ARRAY_SIZE( actions
) && actions
[event
->action
])
1311 fprintf( stderr
, "{action=%s", actions
[event
->action
] );
1313 fprintf( stderr
, "{action=%u", event
->action
);
1314 fprintf( stderr
, ",name=\"%.*s\"}", event
->len
, event
->name
);
1317 if (size
)fputc( ',', stderr
);
1319 fputc( '}', stderr
);
1322 static void dump_varargs_pe_image_info( const char *prefix
, data_size_t size
)
1324 pe_image_info_t info
;
1328 fprintf( stderr
, "%s{}", prefix
);
1331 memset( &info
, 0, sizeof(info
) );
1332 memcpy( &info
, cur_data
, min( size
, sizeof(info
) ));
1334 fprintf( stderr
, "%s{", prefix
);
1335 dump_uint64( "base=", &info
.base
);
1336 dump_uint64( ",stack_size=", &info
.stack_size
);
1337 dump_uint64( ",stack_commit=", &info
.stack_commit
);
1338 fprintf( stderr
, ",entry_point=%08x,map_size=%08x,zerobits=%08x,subsystem=%08x,subsystem_minor=%04x,subsystem_major=%04x"
1339 ",osversion_major=%04x,osversion_minor=%04x,image_charact=%04x,dll_charact=%04x,machine=%04x"
1340 ",contains_code=%u,image_flags=%02x"
1341 ",loader_flags=%08x,header_size=%08x,file_size=%08x,checksum=%08x}",
1342 info
.entry_point
, info
.map_size
, info
.zerobits
, info
.subsystem
, info
.subsystem_minor
,
1343 info
.subsystem_major
, info
.osversion_major
, info
.osversion_minor
, info
.image_charact
,
1344 info
.dll_charact
, info
.machine
, info
.contains_code
, info
.image_flags
, info
.loader_flags
,
1345 info
.header_size
, info
.file_size
, info
.checksum
);
1346 remove_data( min( size
, sizeof(info
) ));
1349 static void dump_varargs_rawinput_devices(const char *prefix
, data_size_t size
)
1351 const struct rawinput_device
*device
;
1353 fprintf( stderr
, "%s{", prefix
);
1354 while (size
>= sizeof(*device
))
1357 fprintf( stderr
, "{usage=%08x,flags=%08x,target=%08x}",
1358 device
->usage
, device
->flags
, device
->target
);
1359 size
-= sizeof(*device
);
1360 remove_data( sizeof(*device
) );
1361 if (size
) fputc( ',', stderr
);
1363 fputc( '}', stderr
);
1366 static void dump_varargs_handle_infos( const char *prefix
, data_size_t size
)
1368 const struct handle_info
*handle
;
1370 fprintf( stderr
, "%s{", prefix
);
1371 while (size
>= sizeof(*handle
))
1374 fprintf( stderr
, "{owner=%04x,handle=%04x,access=%08x,attributes=%08x,type=%u}",
1375 handle
->owner
, handle
->handle
, handle
->access
, handle
->attributes
, handle
->type
);
1376 size
-= sizeof(*handle
);
1377 remove_data( sizeof(*handle
) );
1378 if (size
) fputc( ',', stderr
);
1380 fputc( '}', stderr
);
1383 static void dump_varargs_directory_entries( const char *prefix
, data_size_t size
)
1385 fprintf( stderr
, "%s{", prefix
);
1388 const struct directory_entry
*entry
= cur_data
;
1389 data_size_t entry_size
;
1392 if (size
< sizeof(*entry
) ||
1393 (size
- sizeof(*entry
) < entry
->name_len
) ||
1394 (size
- sizeof(*entry
) - entry
->name_len
< entry
->type_len
))
1396 fprintf( stderr
, "***invalid***}" );
1397 remove_data( size
);
1401 next
= (const char *)(entry
+ 1);
1402 fprintf( stderr
, "{name=L\"" );
1403 dump_strW( (const WCHAR
*)next
, entry
->name_len
, stderr
, "\"\"" );
1404 next
+= entry
->name_len
;
1405 fprintf( stderr
, "\",type=L\"" );
1406 dump_strW( (const WCHAR
*)next
, entry
->type_len
, stderr
, "\"\"" );
1407 fprintf( stderr
, "\"}" );
1409 entry_size
= min( size
, (sizeof(*entry
) + entry
->name_len
+ entry
->type_len
+ 3) & ~3 );
1411 remove_data( entry_size
);
1412 if (size
) fputc( ',', stderr
);
1414 fputc( '}', stderr
);
1417 typedef void (*dump_func
)( const void *req
);
1419 /* Everything below this line is generated automatically by tools/make_requests */
1420 /* ### make_requests begin ### */
1422 static void dump_new_process_request( const struct new_process_request
*req
)
1424 fprintf( stderr
, " token=%04x", req
->token
);
1425 fprintf( stderr
, ", debug=%04x", req
->debug
);
1426 fprintf( stderr
, ", parent_process=%04x", req
->parent_process
);
1427 fprintf( stderr
, ", flags=%08x", req
->flags
);
1428 fprintf( stderr
, ", socket_fd=%d", req
->socket_fd
);
1429 fprintf( stderr
, ", access=%08x", req
->access
);
1430 fprintf( stderr
, ", machine=%04x", req
->machine
);
1431 fprintf( stderr
, ", info_size=%u", req
->info_size
);
1432 fprintf( stderr
, ", handles_size=%u", req
->handles_size
);
1433 fprintf( stderr
, ", jobs_size=%u", req
->jobs_size
);
1434 dump_varargs_object_attributes( ", objattr=", cur_size
);
1435 dump_varargs_uints( ", handles=", min(cur_size
,req
->handles_size
) );
1436 dump_varargs_uints( ", jobs=", min(cur_size
,req
->jobs_size
) );
1437 dump_varargs_startup_info( ", info=", min(cur_size
,req
->info_size
) );
1438 dump_varargs_unicode_str( ", env=", cur_size
);
1441 static void dump_new_process_reply( const struct new_process_reply
*req
)
1443 fprintf( stderr
, " info=%04x", req
->info
);
1444 fprintf( stderr
, ", pid=%04x", req
->pid
);
1445 fprintf( stderr
, ", handle=%04x", req
->handle
);
1448 static void dump_get_new_process_info_request( const struct get_new_process_info_request
*req
)
1450 fprintf( stderr
, " info=%04x", req
->info
);
1453 static void dump_get_new_process_info_reply( const struct get_new_process_info_reply
*req
)
1455 fprintf( stderr
, " success=%d", req
->success
);
1456 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1459 static void dump_new_thread_request( const struct new_thread_request
*req
)
1461 fprintf( stderr
, " process=%04x", req
->process
);
1462 fprintf( stderr
, ", access=%08x", req
->access
);
1463 fprintf( stderr
, ", flags=%08x", req
->flags
);
1464 fprintf( stderr
, ", request_fd=%d", req
->request_fd
);
1465 dump_varargs_object_attributes( ", objattr=", cur_size
);
1468 static void dump_new_thread_reply( const struct new_thread_reply
*req
)
1470 fprintf( stderr
, " tid=%04x", req
->tid
);
1471 fprintf( stderr
, ", handle=%04x", req
->handle
);
1474 static void dump_get_startup_info_request( const struct get_startup_info_request
*req
)
1478 static void dump_get_startup_info_reply( const struct get_startup_info_reply
*req
)
1480 fprintf( stderr
, " info_size=%u", req
->info_size
);
1481 fprintf( stderr
, ", machine=%04x", req
->machine
);
1482 dump_varargs_startup_info( ", info=", min(cur_size
,req
->info_size
) );
1483 dump_varargs_unicode_str( ", env=", cur_size
);
1486 static void dump_init_process_done_request( const struct init_process_done_request
*req
)
1488 dump_uint64( " teb=", &req
->teb
);
1489 dump_uint64( ", peb=", &req
->peb
);
1490 dump_uint64( ", ldt_copy=", &req
->ldt_copy
);
1493 static void dump_init_process_done_reply( const struct init_process_done_reply
*req
)
1495 fprintf( stderr
, " suspend=%d", req
->suspend
);
1498 static void dump_init_first_thread_request( const struct init_first_thread_request
*req
)
1500 fprintf( stderr
, " unix_pid=%d", req
->unix_pid
);
1501 fprintf( stderr
, ", unix_tid=%d", req
->unix_tid
);
1502 fprintf( stderr
, ", debug_level=%d", req
->debug_level
);
1503 fprintf( stderr
, ", reply_fd=%d", req
->reply_fd
);
1504 fprintf( stderr
, ", wait_fd=%d", req
->wait_fd
);
1507 static void dump_init_first_thread_reply( const struct init_first_thread_reply
*req
)
1509 fprintf( stderr
, " pid=%04x", req
->pid
);
1510 fprintf( stderr
, ", tid=%04x", req
->tid
);
1511 dump_timeout( ", server_start=", &req
->server_start
);
1512 fprintf( stderr
, ", session_id=%08x", req
->session_id
);
1513 fprintf( stderr
, ", info_size=%u", req
->info_size
);
1514 dump_varargs_ushorts( ", machines=", cur_size
);
1517 static void dump_init_thread_request( const struct init_thread_request
*req
)
1519 fprintf( stderr
, " unix_tid=%d", req
->unix_tid
);
1520 fprintf( stderr
, ", reply_fd=%d", req
->reply_fd
);
1521 fprintf( stderr
, ", wait_fd=%d", req
->wait_fd
);
1522 dump_uint64( ", teb=", &req
->teb
);
1523 dump_uint64( ", entry=", &req
->entry
);
1526 static void dump_init_thread_reply( const struct init_thread_reply
*req
)
1528 fprintf( stderr
, " suspend=%d", req
->suspend
);
1531 static void dump_terminate_process_request( const struct terminate_process_request
*req
)
1533 fprintf( stderr
, " handle=%04x", req
->handle
);
1534 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1537 static void dump_terminate_process_reply( const struct terminate_process_reply
*req
)
1539 fprintf( stderr
, " self=%d", req
->self
);
1542 static void dump_terminate_thread_request( const struct terminate_thread_request
*req
)
1544 fprintf( stderr
, " handle=%04x", req
->handle
);
1545 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1548 static void dump_terminate_thread_reply( const struct terminate_thread_reply
*req
)
1550 fprintf( stderr
, " self=%d", req
->self
);
1553 static void dump_get_process_info_request( const struct get_process_info_request
*req
)
1555 fprintf( stderr
, " handle=%04x", req
->handle
);
1558 static void dump_get_process_info_reply( const struct get_process_info_reply
*req
)
1560 fprintf( stderr
, " pid=%04x", req
->pid
);
1561 fprintf( stderr
, ", ppid=%04x", req
->ppid
);
1562 dump_uint64( ", affinity=", &req
->affinity
);
1563 dump_uint64( ", peb=", &req
->peb
);
1564 dump_timeout( ", start_time=", &req
->start_time
);
1565 dump_timeout( ", end_time=", &req
->end_time
);
1566 fprintf( stderr
, ", session_id=%08x", req
->session_id
);
1567 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1568 fprintf( stderr
, ", priority=%d", req
->priority
);
1569 fprintf( stderr
, ", machine=%04x", req
->machine
);
1570 dump_varargs_pe_image_info( ", image=", cur_size
);
1573 static void dump_get_process_debug_info_request( const struct get_process_debug_info_request
*req
)
1575 fprintf( stderr
, " handle=%04x", req
->handle
);
1578 static void dump_get_process_debug_info_reply( const struct get_process_debug_info_reply
*req
)
1580 fprintf( stderr
, " debug=%04x", req
->debug
);
1581 fprintf( stderr
, ", debug_children=%d", req
->debug_children
);
1582 dump_varargs_pe_image_info( ", image=", cur_size
);
1585 static void dump_get_process_image_name_request( const struct get_process_image_name_request
*req
)
1587 fprintf( stderr
, " handle=%04x", req
->handle
);
1588 fprintf( stderr
, ", pid=%04x", req
->pid
);
1589 fprintf( stderr
, ", win32=%d", req
->win32
);
1592 static void dump_get_process_image_name_reply( const struct get_process_image_name_reply
*req
)
1594 fprintf( stderr
, " len=%u", req
->len
);
1595 dump_varargs_unicode_str( ", name=", cur_size
);
1598 static void dump_get_process_vm_counters_request( const struct get_process_vm_counters_request
*req
)
1600 fprintf( stderr
, " handle=%04x", req
->handle
);
1603 static void dump_get_process_vm_counters_reply( const struct get_process_vm_counters_reply
*req
)
1605 dump_uint64( " peak_virtual_size=", &req
->peak_virtual_size
);
1606 dump_uint64( ", virtual_size=", &req
->virtual_size
);
1607 dump_uint64( ", peak_working_set_size=", &req
->peak_working_set_size
);
1608 dump_uint64( ", working_set_size=", &req
->working_set_size
);
1609 dump_uint64( ", pagefile_usage=", &req
->pagefile_usage
);
1610 dump_uint64( ", peak_pagefile_usage=", &req
->peak_pagefile_usage
);
1613 static void dump_set_process_info_request( const struct set_process_info_request
*req
)
1615 fprintf( stderr
, " handle=%04x", req
->handle
);
1616 fprintf( stderr
, ", mask=%d", req
->mask
);
1617 fprintf( stderr
, ", priority=%d", req
->priority
);
1618 dump_uint64( ", affinity=", &req
->affinity
);
1619 fprintf( stderr
, ", token=%04x", req
->token
);
1622 static void dump_get_thread_info_request( const struct get_thread_info_request
*req
)
1624 fprintf( stderr
, " handle=%04x", req
->handle
);
1625 fprintf( stderr
, ", access=%08x", req
->access
);
1628 static void dump_get_thread_info_reply( const struct get_thread_info_reply
*req
)
1630 fprintf( stderr
, " pid=%04x", req
->pid
);
1631 fprintf( stderr
, ", tid=%04x", req
->tid
);
1632 dump_uint64( ", teb=", &req
->teb
);
1633 dump_uint64( ", entry_point=", &req
->entry_point
);
1634 dump_uint64( ", affinity=", &req
->affinity
);
1635 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1636 fprintf( stderr
, ", priority=%d", req
->priority
);
1637 fprintf( stderr
, ", last=%d", req
->last
);
1638 fprintf( stderr
, ", suspend_count=%d", req
->suspend_count
);
1639 fprintf( stderr
, ", flags=%08x", req
->flags
);
1640 fprintf( stderr
, ", desc_len=%u", req
->desc_len
);
1641 dump_varargs_unicode_str( ", desc=", cur_size
);
1644 static void dump_get_thread_times_request( const struct get_thread_times_request
*req
)
1646 fprintf( stderr
, " handle=%04x", req
->handle
);
1649 static void dump_get_thread_times_reply( const struct get_thread_times_reply
*req
)
1651 dump_timeout( " creation_time=", &req
->creation_time
);
1652 dump_timeout( ", exit_time=", &req
->exit_time
);
1653 fprintf( stderr
, ", unix_pid=%d", req
->unix_pid
);
1654 fprintf( stderr
, ", unix_tid=%d", req
->unix_tid
);
1657 static void dump_set_thread_info_request( const struct set_thread_info_request
*req
)
1659 fprintf( stderr
, " handle=%04x", req
->handle
);
1660 fprintf( stderr
, ", mask=%d", req
->mask
);
1661 fprintf( stderr
, ", priority=%d", req
->priority
);
1662 dump_uint64( ", affinity=", &req
->affinity
);
1663 dump_uint64( ", entry_point=", &req
->entry_point
);
1664 fprintf( stderr
, ", token=%04x", req
->token
);
1665 dump_varargs_unicode_str( ", desc=", cur_size
);
1668 static void dump_suspend_thread_request( const struct suspend_thread_request
*req
)
1670 fprintf( stderr
, " handle=%04x", req
->handle
);
1673 static void dump_suspend_thread_reply( const struct suspend_thread_reply
*req
)
1675 fprintf( stderr
, " count=%d", req
->count
);
1678 static void dump_resume_thread_request( const struct resume_thread_request
*req
)
1680 fprintf( stderr
, " handle=%04x", req
->handle
);
1683 static void dump_resume_thread_reply( const struct resume_thread_reply
*req
)
1685 fprintf( stderr
, " count=%d", req
->count
);
1688 static void dump_queue_apc_request( const struct queue_apc_request
*req
)
1690 fprintf( stderr
, " handle=%04x", req
->handle
);
1691 dump_varargs_apc_call( ", call=", cur_size
);
1694 static void dump_queue_apc_reply( const struct queue_apc_reply
*req
)
1696 fprintf( stderr
, " handle=%04x", req
->handle
);
1697 fprintf( stderr
, ", self=%d", req
->self
);
1700 static void dump_get_apc_result_request( const struct get_apc_result_request
*req
)
1702 fprintf( stderr
, " handle=%04x", req
->handle
);
1705 static void dump_get_apc_result_reply( const struct get_apc_result_reply
*req
)
1707 dump_apc_result( " result=", &req
->result
);
1710 static void dump_close_handle_request( const struct close_handle_request
*req
)
1712 fprintf( stderr
, " handle=%04x", req
->handle
);
1715 static void dump_set_handle_info_request( const struct set_handle_info_request
*req
)
1717 fprintf( stderr
, " handle=%04x", req
->handle
);
1718 fprintf( stderr
, ", flags=%d", req
->flags
);
1719 fprintf( stderr
, ", mask=%d", req
->mask
);
1722 static void dump_set_handle_info_reply( const struct set_handle_info_reply
*req
)
1724 fprintf( stderr
, " old_flags=%d", req
->old_flags
);
1727 static void dump_dup_handle_request( const struct dup_handle_request
*req
)
1729 fprintf( stderr
, " src_process=%04x", req
->src_process
);
1730 fprintf( stderr
, ", src_handle=%04x", req
->src_handle
);
1731 fprintf( stderr
, ", dst_process=%04x", req
->dst_process
);
1732 fprintf( stderr
, ", access=%08x", req
->access
);
1733 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1734 fprintf( stderr
, ", options=%08x", req
->options
);
1737 static void dump_dup_handle_reply( const struct dup_handle_reply
*req
)
1739 fprintf( stderr
, " handle=%04x", req
->handle
);
1742 static void dump_compare_objects_request( const struct compare_objects_request
*req
)
1744 fprintf( stderr
, " first=%04x", req
->first
);
1745 fprintf( stderr
, ", second=%04x", req
->second
);
1748 static void dump_set_object_permanence_request( const struct set_object_permanence_request
*req
)
1750 fprintf( stderr
, " handle=%04x", req
->handle
);
1751 fprintf( stderr
, ", permanent=%d", req
->permanent
);
1754 static void dump_open_process_request( const struct open_process_request
*req
)
1756 fprintf( stderr
, " pid=%04x", req
->pid
);
1757 fprintf( stderr
, ", access=%08x", req
->access
);
1758 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1761 static void dump_open_process_reply( const struct open_process_reply
*req
)
1763 fprintf( stderr
, " handle=%04x", req
->handle
);
1766 static void dump_open_thread_request( const struct open_thread_request
*req
)
1768 fprintf( stderr
, " tid=%04x", req
->tid
);
1769 fprintf( stderr
, ", access=%08x", req
->access
);
1770 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1773 static void dump_open_thread_reply( const struct open_thread_reply
*req
)
1775 fprintf( stderr
, " handle=%04x", req
->handle
);
1778 static void dump_select_request( const struct select_request
*req
)
1780 fprintf( stderr
, " flags=%d", req
->flags
);
1781 dump_uint64( ", cookie=", &req
->cookie
);
1782 dump_abstime( ", timeout=", &req
->timeout
);
1783 fprintf( stderr
, ", size=%u", req
->size
);
1784 fprintf( stderr
, ", prev_apc=%04x", req
->prev_apc
);
1785 dump_varargs_apc_result( ", result=", cur_size
);
1786 dump_varargs_select_op( ", data=", min(cur_size
,req
->size
) );
1787 dump_varargs_contexts( ", contexts=", cur_size
);
1790 static void dump_select_reply( const struct select_reply
*req
)
1792 fprintf( stderr
, " apc_handle=%04x", req
->apc_handle
);
1793 fprintf( stderr
, ", signaled=%d", req
->signaled
);
1794 dump_varargs_apc_call( ", call=", cur_size
);
1795 dump_varargs_contexts( ", contexts=", cur_size
);
1798 static void dump_create_event_request( const struct create_event_request
*req
)
1800 fprintf( stderr
, " access=%08x", req
->access
);
1801 fprintf( stderr
, ", manual_reset=%d", req
->manual_reset
);
1802 fprintf( stderr
, ", initial_state=%d", req
->initial_state
);
1803 dump_varargs_object_attributes( ", objattr=", cur_size
);
1806 static void dump_create_event_reply( const struct create_event_reply
*req
)
1808 fprintf( stderr
, " handle=%04x", req
->handle
);
1811 static void dump_event_op_request( const struct event_op_request
*req
)
1813 fprintf( stderr
, " handle=%04x", req
->handle
);
1814 fprintf( stderr
, ", op=%d", req
->op
);
1817 static void dump_event_op_reply( const struct event_op_reply
*req
)
1819 fprintf( stderr
, " state=%d", req
->state
);
1822 static void dump_query_event_request( const struct query_event_request
*req
)
1824 fprintf( stderr
, " handle=%04x", req
->handle
);
1827 static void dump_query_event_reply( const struct query_event_reply
*req
)
1829 fprintf( stderr
, " manual_reset=%d", req
->manual_reset
);
1830 fprintf( stderr
, ", state=%d", req
->state
);
1833 static void dump_open_event_request( const struct open_event_request
*req
)
1835 fprintf( stderr
, " access=%08x", req
->access
);
1836 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1837 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1838 dump_varargs_unicode_str( ", name=", cur_size
);
1841 static void dump_open_event_reply( const struct open_event_reply
*req
)
1843 fprintf( stderr
, " handle=%04x", req
->handle
);
1846 static void dump_create_keyed_event_request( const struct create_keyed_event_request
*req
)
1848 fprintf( stderr
, " access=%08x", req
->access
);
1849 dump_varargs_object_attributes( ", objattr=", cur_size
);
1852 static void dump_create_keyed_event_reply( const struct create_keyed_event_reply
*req
)
1854 fprintf( stderr
, " handle=%04x", req
->handle
);
1857 static void dump_open_keyed_event_request( const struct open_keyed_event_request
*req
)
1859 fprintf( stderr
, " access=%08x", req
->access
);
1860 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1861 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1862 dump_varargs_unicode_str( ", name=", cur_size
);
1865 static void dump_open_keyed_event_reply( const struct open_keyed_event_reply
*req
)
1867 fprintf( stderr
, " handle=%04x", req
->handle
);
1870 static void dump_create_mutex_request( const struct create_mutex_request
*req
)
1872 fprintf( stderr
, " access=%08x", req
->access
);
1873 fprintf( stderr
, ", owned=%d", req
->owned
);
1874 dump_varargs_object_attributes( ", objattr=", cur_size
);
1877 static void dump_create_mutex_reply( const struct create_mutex_reply
*req
)
1879 fprintf( stderr
, " handle=%04x", req
->handle
);
1882 static void dump_release_mutex_request( const struct release_mutex_request
*req
)
1884 fprintf( stderr
, " handle=%04x", req
->handle
);
1887 static void dump_release_mutex_reply( const struct release_mutex_reply
*req
)
1889 fprintf( stderr
, " prev_count=%08x", req
->prev_count
);
1892 static void dump_open_mutex_request( const struct open_mutex_request
*req
)
1894 fprintf( stderr
, " access=%08x", req
->access
);
1895 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1896 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1897 dump_varargs_unicode_str( ", name=", cur_size
);
1900 static void dump_open_mutex_reply( const struct open_mutex_reply
*req
)
1902 fprintf( stderr
, " handle=%04x", req
->handle
);
1905 static void dump_query_mutex_request( const struct query_mutex_request
*req
)
1907 fprintf( stderr
, " handle=%04x", req
->handle
);
1910 static void dump_query_mutex_reply( const struct query_mutex_reply
*req
)
1912 fprintf( stderr
, " count=%08x", req
->count
);
1913 fprintf( stderr
, ", owned=%d", req
->owned
);
1914 fprintf( stderr
, ", abandoned=%d", req
->abandoned
);
1917 static void dump_create_semaphore_request( const struct create_semaphore_request
*req
)
1919 fprintf( stderr
, " access=%08x", req
->access
);
1920 fprintf( stderr
, ", initial=%08x", req
->initial
);
1921 fprintf( stderr
, ", max=%08x", req
->max
);
1922 dump_varargs_object_attributes( ", objattr=", cur_size
);
1925 static void dump_create_semaphore_reply( const struct create_semaphore_reply
*req
)
1927 fprintf( stderr
, " handle=%04x", req
->handle
);
1930 static void dump_release_semaphore_request( const struct release_semaphore_request
*req
)
1932 fprintf( stderr
, " handle=%04x", req
->handle
);
1933 fprintf( stderr
, ", count=%08x", req
->count
);
1936 static void dump_release_semaphore_reply( const struct release_semaphore_reply
*req
)
1938 fprintf( stderr
, " prev_count=%08x", req
->prev_count
);
1941 static void dump_query_semaphore_request( const struct query_semaphore_request
*req
)
1943 fprintf( stderr
, " handle=%04x", req
->handle
);
1946 static void dump_query_semaphore_reply( const struct query_semaphore_reply
*req
)
1948 fprintf( stderr
, " current=%08x", req
->current
);
1949 fprintf( stderr
, ", max=%08x", req
->max
);
1952 static void dump_open_semaphore_request( const struct open_semaphore_request
*req
)
1954 fprintf( stderr
, " access=%08x", req
->access
);
1955 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1956 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1957 dump_varargs_unicode_str( ", name=", cur_size
);
1960 static void dump_open_semaphore_reply( const struct open_semaphore_reply
*req
)
1962 fprintf( stderr
, " handle=%04x", req
->handle
);
1965 static void dump_create_file_request( const struct create_file_request
*req
)
1967 fprintf( stderr
, " access=%08x", req
->access
);
1968 fprintf( stderr
, ", sharing=%08x", req
->sharing
);
1969 fprintf( stderr
, ", create=%d", req
->create
);
1970 fprintf( stderr
, ", options=%08x", req
->options
);
1971 fprintf( stderr
, ", attrs=%08x", req
->attrs
);
1972 dump_varargs_object_attributes( ", objattr=", cur_size
);
1973 dump_varargs_string( ", filename=", cur_size
);
1976 static void dump_create_file_reply( const struct create_file_reply
*req
)
1978 fprintf( stderr
, " handle=%04x", req
->handle
);
1981 static void dump_open_file_object_request( const struct open_file_object_request
*req
)
1983 fprintf( stderr
, " access=%08x", req
->access
);
1984 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1985 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1986 fprintf( stderr
, ", sharing=%08x", req
->sharing
);
1987 fprintf( stderr
, ", options=%08x", req
->options
);
1988 dump_varargs_unicode_str( ", filename=", cur_size
);
1991 static void dump_open_file_object_reply( const struct open_file_object_reply
*req
)
1993 fprintf( stderr
, " handle=%04x", req
->handle
);
1996 static void dump_alloc_file_handle_request( const struct alloc_file_handle_request
*req
)
1998 fprintf( stderr
, " access=%08x", req
->access
);
1999 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2000 fprintf( stderr
, ", fd=%d", req
->fd
);
2003 static void dump_alloc_file_handle_reply( const struct alloc_file_handle_reply
*req
)
2005 fprintf( stderr
, " handle=%04x", req
->handle
);
2008 static void dump_get_handle_unix_name_request( const struct get_handle_unix_name_request
*req
)
2010 fprintf( stderr
, " handle=%04x", req
->handle
);
2013 static void dump_get_handle_unix_name_reply( const struct get_handle_unix_name_reply
*req
)
2015 fprintf( stderr
, " name_len=%u", req
->name_len
);
2016 dump_varargs_string( ", name=", cur_size
);
2019 static void dump_get_handle_fd_request( const struct get_handle_fd_request
*req
)
2021 fprintf( stderr
, " handle=%04x", req
->handle
);
2024 static void dump_get_handle_fd_reply( const struct get_handle_fd_reply
*req
)
2026 fprintf( stderr
, " type=%d", req
->type
);
2027 fprintf( stderr
, ", cacheable=%d", req
->cacheable
);
2028 fprintf( stderr
, ", access=%08x", req
->access
);
2029 fprintf( stderr
, ", options=%08x", req
->options
);
2032 static void dump_get_directory_cache_entry_request( const struct get_directory_cache_entry_request
*req
)
2034 fprintf( stderr
, " handle=%04x", req
->handle
);
2037 static void dump_get_directory_cache_entry_reply( const struct get_directory_cache_entry_reply
*req
)
2039 fprintf( stderr
, " entry=%d", req
->entry
);
2040 dump_varargs_ints( ", free=", cur_size
);
2043 static void dump_flush_request( const struct flush_request
*req
)
2045 dump_async_data( " async=", &req
->async
);
2048 static void dump_flush_reply( const struct flush_reply
*req
)
2050 fprintf( stderr
, " event=%04x", req
->event
);
2053 static void dump_get_file_info_request( const struct get_file_info_request
*req
)
2055 fprintf( stderr
, " handle=%04x", req
->handle
);
2056 fprintf( stderr
, ", info_class=%08x", req
->info_class
);
2059 static void dump_get_file_info_reply( const struct get_file_info_reply
*req
)
2061 dump_varargs_bytes( " data=", cur_size
);
2064 static void dump_get_volume_info_request( const struct get_volume_info_request
*req
)
2066 fprintf( stderr
, " handle=%04x", req
->handle
);
2067 dump_async_data( ", async=", &req
->async
);
2068 fprintf( stderr
, ", info_class=%08x", req
->info_class
);
2071 static void dump_get_volume_info_reply( const struct get_volume_info_reply
*req
)
2073 fprintf( stderr
, " wait=%04x", req
->wait
);
2074 dump_varargs_bytes( ", data=", cur_size
);
2077 static void dump_lock_file_request( const struct lock_file_request
*req
)
2079 fprintf( stderr
, " handle=%04x", req
->handle
);
2080 dump_uint64( ", offset=", &req
->offset
);
2081 dump_uint64( ", count=", &req
->count
);
2082 fprintf( stderr
, ", shared=%d", req
->shared
);
2083 fprintf( stderr
, ", wait=%d", req
->wait
);
2086 static void dump_lock_file_reply( const struct lock_file_reply
*req
)
2088 fprintf( stderr
, " handle=%04x", req
->handle
);
2089 fprintf( stderr
, ", overlapped=%d", req
->overlapped
);
2092 static void dump_unlock_file_request( const struct unlock_file_request
*req
)
2094 fprintf( stderr
, " handle=%04x", req
->handle
);
2095 dump_uint64( ", offset=", &req
->offset
);
2096 dump_uint64( ", count=", &req
->count
);
2099 static void dump_recv_socket_request( const struct recv_socket_request
*req
)
2101 fprintf( stderr
, " oob=%d", req
->oob
);
2102 dump_async_data( ", async=", &req
->async
);
2103 fprintf( stderr
, ", force_async=%d", req
->force_async
);
2106 static void dump_recv_socket_reply( const struct recv_socket_reply
*req
)
2108 fprintf( stderr
, " wait=%04x", req
->wait
);
2109 fprintf( stderr
, ", options=%08x", req
->options
);
2110 fprintf( stderr
, ", nonblocking=%d", req
->nonblocking
);
2113 static void dump_send_socket_request( const struct send_socket_request
*req
)
2115 dump_async_data( " async=", &req
->async
);
2116 fprintf( stderr
, ", force_async=%d", req
->force_async
);
2119 static void dump_send_socket_reply( const struct send_socket_reply
*req
)
2121 fprintf( stderr
, " wait=%04x", req
->wait
);
2122 fprintf( stderr
, ", options=%08x", req
->options
);
2123 fprintf( stderr
, ", nonblocking=%d", req
->nonblocking
);
2126 static void dump_socket_get_events_request( const struct socket_get_events_request
*req
)
2128 fprintf( stderr
, " handle=%04x", req
->handle
);
2129 fprintf( stderr
, ", event=%04x", req
->event
);
2132 static void dump_socket_get_events_reply( const struct socket_get_events_reply
*req
)
2134 fprintf( stderr
, " flags=%08x", req
->flags
);
2135 dump_varargs_uints( ", status=", cur_size
);
2138 static void dump_socket_send_icmp_id_request( const struct socket_send_icmp_id_request
*req
)
2140 fprintf( stderr
, " handle=%04x", req
->handle
);
2141 fprintf( stderr
, ", icmp_id=%04x", req
->icmp_id
);
2142 fprintf( stderr
, ", icmp_seq=%04x", req
->icmp_seq
);
2145 static void dump_socket_get_icmp_id_request( const struct socket_get_icmp_id_request
*req
)
2147 fprintf( stderr
, " handle=%04x", req
->handle
);
2148 fprintf( stderr
, ", icmp_seq=%04x", req
->icmp_seq
);
2151 static void dump_socket_get_icmp_id_reply( const struct socket_get_icmp_id_reply
*req
)
2153 fprintf( stderr
, " icmp_id=%04x", req
->icmp_id
);
2156 static void dump_get_next_console_request_request( const struct get_next_console_request_request
*req
)
2158 fprintf( stderr
, " handle=%04x", req
->handle
);
2159 fprintf( stderr
, ", signal=%d", req
->signal
);
2160 fprintf( stderr
, ", read=%d", req
->read
);
2161 fprintf( stderr
, ", status=%08x", req
->status
);
2162 dump_varargs_bytes( ", out_data=", cur_size
);
2165 static void dump_get_next_console_request_reply( const struct get_next_console_request_reply
*req
)
2167 fprintf( stderr
, " code=%08x", req
->code
);
2168 fprintf( stderr
, ", output=%08x", req
->output
);
2169 fprintf( stderr
, ", out_size=%u", req
->out_size
);
2170 dump_varargs_bytes( ", in_data=", cur_size
);
2173 static void dump_read_directory_changes_request( const struct read_directory_changes_request
*req
)
2175 fprintf( stderr
, " filter=%08x", req
->filter
);
2176 fprintf( stderr
, ", subtree=%d", req
->subtree
);
2177 fprintf( stderr
, ", want_data=%d", req
->want_data
);
2178 dump_async_data( ", async=", &req
->async
);
2181 static void dump_read_change_request( const struct read_change_request
*req
)
2183 fprintf( stderr
, " handle=%04x", req
->handle
);
2186 static void dump_read_change_reply( const struct read_change_reply
*req
)
2188 dump_varargs_filesystem_event( " events=", cur_size
);
2191 static void dump_create_mapping_request( const struct create_mapping_request
*req
)
2193 fprintf( stderr
, " access=%08x", req
->access
);
2194 fprintf( stderr
, ", flags=%08x", req
->flags
);
2195 fprintf( stderr
, ", file_access=%08x", req
->file_access
);
2196 dump_uint64( ", size=", &req
->size
);
2197 fprintf( stderr
, ", file_handle=%04x", req
->file_handle
);
2198 dump_varargs_object_attributes( ", objattr=", cur_size
);
2201 static void dump_create_mapping_reply( const struct create_mapping_reply
*req
)
2203 fprintf( stderr
, " handle=%04x", req
->handle
);
2206 static void dump_open_mapping_request( const struct open_mapping_request
*req
)
2208 fprintf( stderr
, " access=%08x", req
->access
);
2209 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2210 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
2211 dump_varargs_unicode_str( ", name=", cur_size
);
2214 static void dump_open_mapping_reply( const struct open_mapping_reply
*req
)
2216 fprintf( stderr
, " handle=%04x", req
->handle
);
2219 static void dump_get_mapping_info_request( const struct get_mapping_info_request
*req
)
2221 fprintf( stderr
, " handle=%04x", req
->handle
);
2222 fprintf( stderr
, ", access=%08x", req
->access
);
2225 static void dump_get_mapping_info_reply( const struct get_mapping_info_reply
*req
)
2227 dump_uint64( " size=", &req
->size
);
2228 fprintf( stderr
, ", flags=%08x", req
->flags
);
2229 fprintf( stderr
, ", shared_file=%04x", req
->shared_file
);
2230 fprintf( stderr
, ", total=%u", req
->total
);
2231 dump_varargs_pe_image_info( ", image=", cur_size
);
2232 dump_varargs_unicode_str( ", name=", cur_size
);
2235 static void dump_get_image_map_address_request( const struct get_image_map_address_request
*req
)
2237 fprintf( stderr
, " handle=%04x", req
->handle
);
2240 static void dump_get_image_map_address_reply( const struct get_image_map_address_reply
*req
)
2242 dump_uint64( " addr=", &req
->addr
);
2245 static void dump_map_view_request( const struct map_view_request
*req
)
2247 fprintf( stderr
, " mapping=%04x", req
->mapping
);
2248 fprintf( stderr
, ", access=%08x", req
->access
);
2249 dump_uint64( ", base=", &req
->base
);
2250 dump_uint64( ", size=", &req
->size
);
2251 dump_uint64( ", start=", &req
->start
);
2254 static void dump_map_image_view_request( const struct map_image_view_request
*req
)
2256 fprintf( stderr
, " mapping=%04x", req
->mapping
);
2257 dump_uint64( ", base=", &req
->base
);
2258 dump_uint64( ", size=", &req
->size
);
2259 fprintf( stderr
, ", entry=%08x", req
->entry
);
2260 fprintf( stderr
, ", machine=%04x", req
->machine
);
2263 static void dump_map_builtin_view_request( const struct map_builtin_view_request
*req
)
2265 dump_varargs_pe_image_info( " image=", cur_size
);
2266 dump_varargs_unicode_str( ", name=", cur_size
);
2269 static void dump_get_image_view_info_request( const struct get_image_view_info_request
*req
)
2271 fprintf( stderr
, " process=%04x", req
->process
);
2272 dump_uint64( ", addr=", &req
->addr
);
2275 static void dump_get_image_view_info_reply( const struct get_image_view_info_reply
*req
)
2277 dump_uint64( " base=", &req
->base
);
2278 dump_uint64( ", size=", &req
->size
);
2281 static void dump_unmap_view_request( const struct unmap_view_request
*req
)
2283 dump_uint64( " base=", &req
->base
);
2286 static void dump_get_mapping_committed_range_request( const struct get_mapping_committed_range_request
*req
)
2288 dump_uint64( " base=", &req
->base
);
2289 dump_uint64( ", offset=", &req
->offset
);
2292 static void dump_get_mapping_committed_range_reply( const struct get_mapping_committed_range_reply
*req
)
2294 dump_uint64( " size=", &req
->size
);
2295 fprintf( stderr
, ", committed=%d", req
->committed
);
2298 static void dump_add_mapping_committed_range_request( const struct add_mapping_committed_range_request
*req
)
2300 dump_uint64( " base=", &req
->base
);
2301 dump_uint64( ", offset=", &req
->offset
);
2302 dump_uint64( ", size=", &req
->size
);
2305 static void dump_is_same_mapping_request( const struct is_same_mapping_request
*req
)
2307 dump_uint64( " base1=", &req
->base1
);
2308 dump_uint64( ", base2=", &req
->base2
);
2311 static void dump_get_mapping_filename_request( const struct get_mapping_filename_request
*req
)
2313 fprintf( stderr
, " process=%04x", req
->process
);
2314 dump_uint64( ", addr=", &req
->addr
);
2317 static void dump_get_mapping_filename_reply( const struct get_mapping_filename_reply
*req
)
2319 fprintf( stderr
, " len=%u", req
->len
);
2320 dump_varargs_unicode_str( ", filename=", cur_size
);
2323 static void dump_list_processes_request( const struct list_processes_request
*req
)
2327 static void dump_list_processes_reply( const struct list_processes_reply
*req
)
2329 fprintf( stderr
, " info_size=%u", req
->info_size
);
2330 fprintf( stderr
, ", process_count=%d", req
->process_count
);
2331 fprintf( stderr
, ", total_thread_count=%d", req
->total_thread_count
);
2332 fprintf( stderr
, ", total_name_len=%u", req
->total_name_len
);
2333 dump_varargs_process_info( ", data=", min(cur_size
,req
->info_size
) );
2336 static void dump_create_debug_obj_request( const struct create_debug_obj_request
*req
)
2338 fprintf( stderr
, " access=%08x", req
->access
);
2339 fprintf( stderr
, ", flags=%08x", req
->flags
);
2340 dump_varargs_object_attributes( ", objattr=", cur_size
);
2343 static void dump_create_debug_obj_reply( const struct create_debug_obj_reply
*req
)
2345 fprintf( stderr
, " handle=%04x", req
->handle
);
2348 static void dump_wait_debug_event_request( const struct wait_debug_event_request
*req
)
2350 fprintf( stderr
, " debug=%04x", req
->debug
);
2353 static void dump_wait_debug_event_reply( const struct wait_debug_event_reply
*req
)
2355 fprintf( stderr
, " pid=%04x", req
->pid
);
2356 fprintf( stderr
, ", tid=%04x", req
->tid
);
2357 dump_varargs_debug_event( ", event=", cur_size
);
2360 static void dump_queue_exception_event_request( const struct queue_exception_event_request
*req
)
2362 fprintf( stderr
, " first=%d", req
->first
);
2363 fprintf( stderr
, ", code=%08x", req
->code
);
2364 fprintf( stderr
, ", flags=%08x", req
->flags
);
2365 dump_uint64( ", record=", &req
->record
);
2366 dump_uint64( ", address=", &req
->address
);
2367 fprintf( stderr
, ", len=%u", req
->len
);
2368 dump_varargs_uints64( ", params=", min(cur_size
,req
->len
) );
2371 static void dump_queue_exception_event_reply( const struct queue_exception_event_reply
*req
)
2373 fprintf( stderr
, " handle=%04x", req
->handle
);
2376 static void dump_get_exception_status_request( const struct get_exception_status_request
*req
)
2378 fprintf( stderr
, " handle=%04x", req
->handle
);
2381 static void dump_continue_debug_event_request( const struct continue_debug_event_request
*req
)
2383 fprintf( stderr
, " debug=%04x", req
->debug
);
2384 fprintf( stderr
, ", pid=%04x", req
->pid
);
2385 fprintf( stderr
, ", tid=%04x", req
->tid
);
2386 fprintf( stderr
, ", status=%08x", req
->status
);
2389 static void dump_debug_process_request( const struct debug_process_request
*req
)
2391 fprintf( stderr
, " handle=%04x", req
->handle
);
2392 fprintf( stderr
, ", debug=%04x", req
->debug
);
2393 fprintf( stderr
, ", attach=%d", req
->attach
);
2396 static void dump_set_debug_obj_info_request( const struct set_debug_obj_info_request
*req
)
2398 fprintf( stderr
, " debug=%04x", req
->debug
);
2399 fprintf( stderr
, ", flags=%08x", req
->flags
);
2402 static void dump_read_process_memory_request( const struct read_process_memory_request
*req
)
2404 fprintf( stderr
, " handle=%04x", req
->handle
);
2405 dump_uint64( ", addr=", &req
->addr
);
2408 static void dump_read_process_memory_reply( const struct read_process_memory_reply
*req
)
2410 dump_varargs_bytes( " data=", cur_size
);
2413 static void dump_write_process_memory_request( const struct write_process_memory_request
*req
)
2415 fprintf( stderr
, " handle=%04x", req
->handle
);
2416 dump_uint64( ", addr=", &req
->addr
);
2417 dump_varargs_bytes( ", data=", cur_size
);
2420 static void dump_create_key_request( const struct create_key_request
*req
)
2422 fprintf( stderr
, " access=%08x", req
->access
);
2423 fprintf( stderr
, ", options=%08x", req
->options
);
2424 dump_varargs_object_attributes( ", objattr=", cur_size
);
2425 dump_varargs_unicode_str( ", class=", cur_size
);
2428 static void dump_create_key_reply( const struct create_key_reply
*req
)
2430 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2433 static void dump_open_key_request( const struct open_key_request
*req
)
2435 fprintf( stderr
, " parent=%04x", req
->parent
);
2436 fprintf( stderr
, ", access=%08x", req
->access
);
2437 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2438 dump_varargs_unicode_str( ", name=", cur_size
);
2441 static void dump_open_key_reply( const struct open_key_reply
*req
)
2443 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2446 static void dump_delete_key_request( const struct delete_key_request
*req
)
2448 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2451 static void dump_flush_key_request( const struct flush_key_request
*req
)
2453 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2456 static void dump_enum_key_request( const struct enum_key_request
*req
)
2458 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2459 fprintf( stderr
, ", index=%d", req
->index
);
2460 fprintf( stderr
, ", info_class=%d", req
->info_class
);
2463 static void dump_enum_key_reply( const struct enum_key_reply
*req
)
2465 fprintf( stderr
, " subkeys=%d", req
->subkeys
);
2466 fprintf( stderr
, ", max_subkey=%d", req
->max_subkey
);
2467 fprintf( stderr
, ", max_class=%d", req
->max_class
);
2468 fprintf( stderr
, ", values=%d", req
->values
);
2469 fprintf( stderr
, ", max_value=%d", req
->max_value
);
2470 fprintf( stderr
, ", max_data=%d", req
->max_data
);
2471 dump_timeout( ", modif=", &req
->modif
);
2472 fprintf( stderr
, ", total=%u", req
->total
);
2473 fprintf( stderr
, ", namelen=%u", req
->namelen
);
2474 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->namelen
) );
2475 dump_varargs_unicode_str( ", class=", cur_size
);
2478 static void dump_set_key_value_request( const struct set_key_value_request
*req
)
2480 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2481 fprintf( stderr
, ", type=%d", req
->type
);
2482 fprintf( stderr
, ", namelen=%u", req
->namelen
);
2483 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->namelen
) );
2484 dump_varargs_bytes( ", data=", cur_size
);
2487 static void dump_get_key_value_request( const struct get_key_value_request
*req
)
2489 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2490 dump_varargs_unicode_str( ", name=", cur_size
);
2493 static void dump_get_key_value_reply( const struct get_key_value_reply
*req
)
2495 fprintf( stderr
, " type=%d", req
->type
);
2496 fprintf( stderr
, ", total=%u", req
->total
);
2497 dump_varargs_bytes( ", data=", cur_size
);
2500 static void dump_enum_key_value_request( const struct enum_key_value_request
*req
)
2502 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2503 fprintf( stderr
, ", index=%d", req
->index
);
2504 fprintf( stderr
, ", info_class=%d", req
->info_class
);
2507 static void dump_enum_key_value_reply( const struct enum_key_value_reply
*req
)
2509 fprintf( stderr
, " type=%d", req
->type
);
2510 fprintf( stderr
, ", total=%u", req
->total
);
2511 fprintf( stderr
, ", namelen=%u", req
->namelen
);
2512 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->namelen
) );
2513 dump_varargs_bytes( ", data=", cur_size
);
2516 static void dump_delete_key_value_request( const struct delete_key_value_request
*req
)
2518 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2519 dump_varargs_unicode_str( ", name=", cur_size
);
2522 static void dump_load_registry_request( const struct load_registry_request
*req
)
2524 fprintf( stderr
, " file=%04x", req
->file
);
2525 dump_varargs_object_attributes( ", objattr=", cur_size
);
2528 static void dump_unload_registry_request( const struct unload_registry_request
*req
)
2530 fprintf( stderr
, " parent=%04x", req
->parent
);
2531 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2532 dump_varargs_unicode_str( ", name=", cur_size
);
2535 static void dump_save_registry_request( const struct save_registry_request
*req
)
2537 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2538 fprintf( stderr
, ", file=%04x", req
->file
);
2541 static void dump_set_registry_notification_request( const struct set_registry_notification_request
*req
)
2543 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2544 fprintf( stderr
, ", event=%04x", req
->event
);
2545 fprintf( stderr
, ", subtree=%d", req
->subtree
);
2546 fprintf( stderr
, ", filter=%08x", req
->filter
);
2549 static void dump_rename_key_request( const struct rename_key_request
*req
)
2551 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2552 dump_varargs_unicode_str( ", name=", cur_size
);
2555 static void dump_create_timer_request( const struct create_timer_request
*req
)
2557 fprintf( stderr
, " access=%08x", req
->access
);
2558 fprintf( stderr
, ", manual=%d", req
->manual
);
2559 dump_varargs_object_attributes( ", objattr=", cur_size
);
2562 static void dump_create_timer_reply( const struct create_timer_reply
*req
)
2564 fprintf( stderr
, " handle=%04x", req
->handle
);
2567 static void dump_open_timer_request( const struct open_timer_request
*req
)
2569 fprintf( stderr
, " access=%08x", req
->access
);
2570 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2571 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
2572 dump_varargs_unicode_str( ", name=", cur_size
);
2575 static void dump_open_timer_reply( const struct open_timer_reply
*req
)
2577 fprintf( stderr
, " handle=%04x", req
->handle
);
2580 static void dump_set_timer_request( const struct set_timer_request
*req
)
2582 fprintf( stderr
, " handle=%04x", req
->handle
);
2583 dump_timeout( ", expire=", &req
->expire
);
2584 dump_uint64( ", callback=", &req
->callback
);
2585 dump_uint64( ", arg=", &req
->arg
);
2586 fprintf( stderr
, ", period=%d", req
->period
);
2589 static void dump_set_timer_reply( const struct set_timer_reply
*req
)
2591 fprintf( stderr
, " signaled=%d", req
->signaled
);
2594 static void dump_cancel_timer_request( const struct cancel_timer_request
*req
)
2596 fprintf( stderr
, " handle=%04x", req
->handle
);
2599 static void dump_cancel_timer_reply( const struct cancel_timer_reply
*req
)
2601 fprintf( stderr
, " signaled=%d", req
->signaled
);
2604 static void dump_get_timer_info_request( const struct get_timer_info_request
*req
)
2606 fprintf( stderr
, " handle=%04x", req
->handle
);
2609 static void dump_get_timer_info_reply( const struct get_timer_info_reply
*req
)
2611 dump_timeout( " when=", &req
->when
);
2612 fprintf( stderr
, ", signaled=%d", req
->signaled
);
2615 static void dump_get_thread_context_request( const struct get_thread_context_request
*req
)
2617 fprintf( stderr
, " handle=%04x", req
->handle
);
2618 fprintf( stderr
, ", context=%04x", req
->context
);
2619 fprintf( stderr
, ", flags=%08x", req
->flags
);
2620 fprintf( stderr
, ", native_flags=%08x", req
->native_flags
);
2621 fprintf( stderr
, ", machine=%04x", req
->machine
);
2624 static void dump_get_thread_context_reply( const struct get_thread_context_reply
*req
)
2626 fprintf( stderr
, " self=%d", req
->self
);
2627 fprintf( stderr
, ", handle=%04x", req
->handle
);
2628 dump_varargs_contexts( ", contexts=", cur_size
);
2631 static void dump_set_thread_context_request( const struct set_thread_context_request
*req
)
2633 fprintf( stderr
, " handle=%04x", req
->handle
);
2634 fprintf( stderr
, ", native_flags=%08x", req
->native_flags
);
2635 dump_varargs_contexts( ", contexts=", cur_size
);
2638 static void dump_set_thread_context_reply( const struct set_thread_context_reply
*req
)
2640 fprintf( stderr
, " self=%d", req
->self
);
2643 static void dump_get_selector_entry_request( const struct get_selector_entry_request
*req
)
2645 fprintf( stderr
, " handle=%04x", req
->handle
);
2646 fprintf( stderr
, ", entry=%d", req
->entry
);
2649 static void dump_get_selector_entry_reply( const struct get_selector_entry_reply
*req
)
2651 fprintf( stderr
, " base=%08x", req
->base
);
2652 fprintf( stderr
, ", limit=%08x", req
->limit
);
2653 fprintf( stderr
, ", flags=%02x", req
->flags
);
2656 static void dump_add_atom_request( const struct add_atom_request
*req
)
2658 dump_varargs_unicode_str( " name=", cur_size
);
2661 static void dump_add_atom_reply( const struct add_atom_reply
*req
)
2663 fprintf( stderr
, " atom=%04x", req
->atom
);
2666 static void dump_delete_atom_request( const struct delete_atom_request
*req
)
2668 fprintf( stderr
, " atom=%04x", req
->atom
);
2671 static void dump_find_atom_request( const struct find_atom_request
*req
)
2673 dump_varargs_unicode_str( " name=", cur_size
);
2676 static void dump_find_atom_reply( const struct find_atom_reply
*req
)
2678 fprintf( stderr
, " atom=%04x", req
->atom
);
2681 static void dump_get_atom_information_request( const struct get_atom_information_request
*req
)
2683 fprintf( stderr
, " atom=%04x", req
->atom
);
2686 static void dump_get_atom_information_reply( const struct get_atom_information_reply
*req
)
2688 fprintf( stderr
, " count=%d", req
->count
);
2689 fprintf( stderr
, ", pinned=%d", req
->pinned
);
2690 fprintf( stderr
, ", total=%u", req
->total
);
2691 dump_varargs_unicode_str( ", name=", cur_size
);
2694 static void dump_get_msg_queue_request( const struct get_msg_queue_request
*req
)
2698 static void dump_get_msg_queue_reply( const struct get_msg_queue_reply
*req
)
2700 fprintf( stderr
, " handle=%04x", req
->handle
);
2703 static void dump_set_queue_fd_request( const struct set_queue_fd_request
*req
)
2705 fprintf( stderr
, " handle=%04x", req
->handle
);
2708 static void dump_set_queue_mask_request( const struct set_queue_mask_request
*req
)
2710 fprintf( stderr
, " wake_mask=%08x", req
->wake_mask
);
2711 fprintf( stderr
, ", changed_mask=%08x", req
->changed_mask
);
2712 fprintf( stderr
, ", skip_wait=%d", req
->skip_wait
);
2715 static void dump_set_queue_mask_reply( const struct set_queue_mask_reply
*req
)
2717 fprintf( stderr
, " wake_bits=%08x", req
->wake_bits
);
2718 fprintf( stderr
, ", changed_bits=%08x", req
->changed_bits
);
2721 static void dump_get_queue_status_request( const struct get_queue_status_request
*req
)
2723 fprintf( stderr
, " clear_bits=%08x", req
->clear_bits
);
2726 static void dump_get_queue_status_reply( const struct get_queue_status_reply
*req
)
2728 fprintf( stderr
, " wake_bits=%08x", req
->wake_bits
);
2729 fprintf( stderr
, ", changed_bits=%08x", req
->changed_bits
);
2732 static void dump_get_process_idle_event_request( const struct get_process_idle_event_request
*req
)
2734 fprintf( stderr
, " handle=%04x", req
->handle
);
2737 static void dump_get_process_idle_event_reply( const struct get_process_idle_event_reply
*req
)
2739 fprintf( stderr
, " event=%04x", req
->event
);
2742 static void dump_send_message_request( const struct send_message_request
*req
)
2744 fprintf( stderr
, " id=%04x", req
->id
);
2745 fprintf( stderr
, ", type=%d", req
->type
);
2746 fprintf( stderr
, ", flags=%d", req
->flags
);
2747 fprintf( stderr
, ", win=%08x", req
->win
);
2748 fprintf( stderr
, ", msg=%08x", req
->msg
);
2749 dump_uint64( ", wparam=", &req
->wparam
);
2750 dump_uint64( ", lparam=", &req
->lparam
);
2751 dump_timeout( ", timeout=", &req
->timeout
);
2752 dump_varargs_message_data( ", data=", cur_size
);
2755 static void dump_post_quit_message_request( const struct post_quit_message_request
*req
)
2757 fprintf( stderr
, " exit_code=%d", req
->exit_code
);
2760 static void dump_send_hardware_message_request( const struct send_hardware_message_request
*req
)
2762 fprintf( stderr
, " win=%08x", req
->win
);
2763 dump_hw_input( ", input=", &req
->input
);
2764 fprintf( stderr
, ", flags=%08x", req
->flags
);
2765 dump_varargs_bytes( ", report=", cur_size
);
2768 static void dump_send_hardware_message_reply( const struct send_hardware_message_reply
*req
)
2770 fprintf( stderr
, " wait=%d", req
->wait
);
2771 fprintf( stderr
, ", prev_x=%d", req
->prev_x
);
2772 fprintf( stderr
, ", prev_y=%d", req
->prev_y
);
2773 fprintf( stderr
, ", new_x=%d", req
->new_x
);
2774 fprintf( stderr
, ", new_y=%d", req
->new_y
);
2777 static void dump_get_message_request( const struct get_message_request
*req
)
2779 fprintf( stderr
, " flags=%08x", req
->flags
);
2780 fprintf( stderr
, ", get_win=%08x", req
->get_win
);
2781 fprintf( stderr
, ", get_first=%08x", req
->get_first
);
2782 fprintf( stderr
, ", get_last=%08x", req
->get_last
);
2783 fprintf( stderr
, ", hw_id=%08x", req
->hw_id
);
2784 fprintf( stderr
, ", wake_mask=%08x", req
->wake_mask
);
2785 fprintf( stderr
, ", changed_mask=%08x", req
->changed_mask
);
2786 fprintf( stderr
, ", internal=%08x", req
->internal
);
2789 static void dump_get_message_reply( const struct get_message_reply
*req
)
2791 fprintf( stderr
, " win=%08x", req
->win
);
2792 fprintf( stderr
, ", msg=%08x", req
->msg
);
2793 dump_uint64( ", wparam=", &req
->wparam
);
2794 dump_uint64( ", lparam=", &req
->lparam
);
2795 fprintf( stderr
, ", type=%d", req
->type
);
2796 fprintf( stderr
, ", x=%d", req
->x
);
2797 fprintf( stderr
, ", y=%d", req
->y
);
2798 fprintf( stderr
, ", time=%08x", req
->time
);
2799 fprintf( stderr
, ", active_hooks=%08x", req
->active_hooks
);
2800 fprintf( stderr
, ", total=%u", req
->total
);
2801 dump_varargs_message_data( ", data=", cur_size
);
2804 static void dump_reply_message_request( const struct reply_message_request
*req
)
2806 fprintf( stderr
, " remove=%d", req
->remove
);
2807 dump_uint64( ", result=", &req
->result
);
2808 dump_varargs_bytes( ", data=", cur_size
);
2811 static void dump_accept_hardware_message_request( const struct accept_hardware_message_request
*req
)
2813 fprintf( stderr
, " hw_id=%08x", req
->hw_id
);
2816 static void dump_get_message_reply_request( const struct get_message_reply_request
*req
)
2818 fprintf( stderr
, " cancel=%d", req
->cancel
);
2821 static void dump_get_message_reply_reply( const struct get_message_reply_reply
*req
)
2823 dump_uint64( " result=", &req
->result
);
2824 dump_varargs_bytes( ", data=", cur_size
);
2827 static void dump_set_win_timer_request( const struct set_win_timer_request
*req
)
2829 fprintf( stderr
, " win=%08x", req
->win
);
2830 fprintf( stderr
, ", msg=%08x", req
->msg
);
2831 fprintf( stderr
, ", rate=%08x", req
->rate
);
2832 dump_uint64( ", id=", &req
->id
);
2833 dump_uint64( ", lparam=", &req
->lparam
);
2836 static void dump_set_win_timer_reply( const struct set_win_timer_reply
*req
)
2838 dump_uint64( " id=", &req
->id
);
2841 static void dump_kill_win_timer_request( const struct kill_win_timer_request
*req
)
2843 fprintf( stderr
, " win=%08x", req
->win
);
2844 dump_uint64( ", id=", &req
->id
);
2845 fprintf( stderr
, ", msg=%08x", req
->msg
);
2848 static void dump_is_window_hung_request( const struct is_window_hung_request
*req
)
2850 fprintf( stderr
, " win=%08x", req
->win
);
2853 static void dump_is_window_hung_reply( const struct is_window_hung_reply
*req
)
2855 fprintf( stderr
, " is_hung=%d", req
->is_hung
);
2858 static void dump_get_serial_info_request( const struct get_serial_info_request
*req
)
2860 fprintf( stderr
, " handle=%04x", req
->handle
);
2861 fprintf( stderr
, ", flags=%d", req
->flags
);
2864 static void dump_get_serial_info_reply( const struct get_serial_info_reply
*req
)
2866 fprintf( stderr
, " eventmask=%08x", req
->eventmask
);
2867 fprintf( stderr
, ", pending_write=%08x", req
->pending_write
);
2870 static void dump_set_serial_info_request( const struct set_serial_info_request
*req
)
2872 fprintf( stderr
, " handle=%04x", req
->handle
);
2873 fprintf( stderr
, ", flags=%d", req
->flags
);
2876 static void dump_cancel_sync_request( const struct cancel_sync_request
*req
)
2878 fprintf( stderr
, " handle=%04x", req
->handle
);
2879 dump_uint64( ", iosb=", &req
->iosb
);
2882 static void dump_register_async_request( const struct register_async_request
*req
)
2884 fprintf( stderr
, " type=%d", req
->type
);
2885 dump_async_data( ", async=", &req
->async
);
2886 fprintf( stderr
, ", count=%d", req
->count
);
2889 static void dump_cancel_async_request( const struct cancel_async_request
*req
)
2891 fprintf( stderr
, " handle=%04x", req
->handle
);
2892 dump_uint64( ", iosb=", &req
->iosb
);
2893 fprintf( stderr
, ", only_thread=%d", req
->only_thread
);
2896 static void dump_get_async_result_request( const struct get_async_result_request
*req
)
2898 dump_uint64( " user_arg=", &req
->user_arg
);
2901 static void dump_get_async_result_reply( const struct get_async_result_reply
*req
)
2903 dump_varargs_bytes( " out_data=", cur_size
);
2906 static void dump_set_async_direct_result_request( const struct set_async_direct_result_request
*req
)
2908 fprintf( stderr
, " handle=%04x", req
->handle
);
2909 dump_uint64( ", information=", &req
->information
);
2910 fprintf( stderr
, ", status=%08x", req
->status
);
2911 fprintf( stderr
, ", mark_pending=%d", req
->mark_pending
);
2914 static void dump_set_async_direct_result_reply( const struct set_async_direct_result_reply
*req
)
2916 fprintf( stderr
, " handle=%04x", req
->handle
);
2919 static void dump_read_request( const struct read_request
*req
)
2921 dump_async_data( " async=", &req
->async
);
2922 dump_uint64( ", pos=", &req
->pos
);
2925 static void dump_read_reply( const struct read_reply
*req
)
2927 fprintf( stderr
, " wait=%04x", req
->wait
);
2928 fprintf( stderr
, ", options=%08x", req
->options
);
2929 dump_varargs_bytes( ", data=", cur_size
);
2932 static void dump_write_request( const struct write_request
*req
)
2934 dump_async_data( " async=", &req
->async
);
2935 dump_uint64( ", pos=", &req
->pos
);
2936 dump_varargs_bytes( ", data=", cur_size
);
2939 static void dump_write_reply( const struct write_reply
*req
)
2941 fprintf( stderr
, " wait=%04x", req
->wait
);
2942 fprintf( stderr
, ", options=%08x", req
->options
);
2943 fprintf( stderr
, ", size=%u", req
->size
);
2946 static void dump_ioctl_request( const struct ioctl_request
*req
)
2948 dump_ioctl_code( " code=", &req
->code
);
2949 dump_async_data( ", async=", &req
->async
);
2950 dump_varargs_bytes( ", in_data=", cur_size
);
2953 static void dump_ioctl_reply( const struct ioctl_reply
*req
)
2955 fprintf( stderr
, " wait=%04x", req
->wait
);
2956 fprintf( stderr
, ", options=%08x", req
->options
);
2957 dump_varargs_bytes( ", out_data=", cur_size
);
2960 static void dump_set_irp_result_request( const struct set_irp_result_request
*req
)
2962 fprintf( stderr
, " handle=%04x", req
->handle
);
2963 fprintf( stderr
, ", status=%08x", req
->status
);
2964 fprintf( stderr
, ", size=%u", req
->size
);
2965 dump_varargs_bytes( ", data=", cur_size
);
2968 static void dump_create_named_pipe_request( const struct create_named_pipe_request
*req
)
2970 fprintf( stderr
, " access=%08x", req
->access
);
2971 fprintf( stderr
, ", options=%08x", req
->options
);
2972 fprintf( stderr
, ", sharing=%08x", req
->sharing
);
2973 fprintf( stderr
, ", disposition=%08x", req
->disposition
);
2974 fprintf( stderr
, ", maxinstances=%08x", req
->maxinstances
);
2975 fprintf( stderr
, ", outsize=%08x", req
->outsize
);
2976 fprintf( stderr
, ", insize=%08x", req
->insize
);
2977 dump_timeout( ", timeout=", &req
->timeout
);
2978 fprintf( stderr
, ", flags=%08x", req
->flags
);
2979 dump_varargs_object_attributes( ", objattr=", cur_size
);
2982 static void dump_create_named_pipe_reply( const struct create_named_pipe_reply
*req
)
2984 fprintf( stderr
, " handle=%04x", req
->handle
);
2985 fprintf( stderr
, ", created=%d", req
->created
);
2988 static void dump_set_named_pipe_info_request( const struct set_named_pipe_info_request
*req
)
2990 fprintf( stderr
, " handle=%04x", req
->handle
);
2991 fprintf( stderr
, ", flags=%08x", req
->flags
);
2994 static void dump_create_window_request( const struct create_window_request
*req
)
2996 fprintf( stderr
, " parent=%08x", req
->parent
);
2997 fprintf( stderr
, ", owner=%08x", req
->owner
);
2998 fprintf( stderr
, ", atom=%04x", req
->atom
);
2999 dump_uint64( ", instance=", &req
->instance
);
3000 fprintf( stderr
, ", dpi_context=%08x", req
->dpi_context
);
3001 fprintf( stderr
, ", style=%08x", req
->style
);
3002 fprintf( stderr
, ", ex_style=%08x", req
->ex_style
);
3003 dump_varargs_unicode_str( ", class=", cur_size
);
3006 static void dump_create_window_reply( const struct create_window_reply
*req
)
3008 fprintf( stderr
, " handle=%08x", req
->handle
);
3009 fprintf( stderr
, ", parent=%08x", req
->parent
);
3010 fprintf( stderr
, ", owner=%08x", req
->owner
);
3011 fprintf( stderr
, ", extra=%d", req
->extra
);
3012 dump_uint64( ", class_ptr=", &req
->class_ptr
);
3013 fprintf( stderr
, ", dpi_context=%08x", req
->dpi_context
);
3016 static void dump_destroy_window_request( const struct destroy_window_request
*req
)
3018 fprintf( stderr
, " handle=%08x", req
->handle
);
3021 static void dump_get_desktop_window_request( const struct get_desktop_window_request
*req
)
3023 fprintf( stderr
, " force=%d", req
->force
);
3026 static void dump_get_desktop_window_reply( const struct get_desktop_window_reply
*req
)
3028 fprintf( stderr
, " top_window=%08x", req
->top_window
);
3029 fprintf( stderr
, ", msg_window=%08x", req
->msg_window
);
3032 static void dump_set_window_owner_request( const struct set_window_owner_request
*req
)
3034 fprintf( stderr
, " handle=%08x", req
->handle
);
3035 fprintf( stderr
, ", owner=%08x", req
->owner
);
3038 static void dump_set_window_owner_reply( const struct set_window_owner_reply
*req
)
3040 fprintf( stderr
, " full_owner=%08x", req
->full_owner
);
3041 fprintf( stderr
, ", prev_owner=%08x", req
->prev_owner
);
3044 static void dump_get_window_info_request( const struct get_window_info_request
*req
)
3046 fprintf( stderr
, " handle=%08x", req
->handle
);
3049 static void dump_get_window_info_reply( const struct get_window_info_reply
*req
)
3051 fprintf( stderr
, " full_handle=%08x", req
->full_handle
);
3052 fprintf( stderr
, ", last_active=%08x", req
->last_active
);
3053 fprintf( stderr
, ", pid=%04x", req
->pid
);
3054 fprintf( stderr
, ", tid=%04x", req
->tid
);
3055 fprintf( stderr
, ", atom=%04x", req
->atom
);
3056 fprintf( stderr
, ", is_unicode=%d", req
->is_unicode
);
3057 fprintf( stderr
, ", dpi_context=%08x", req
->dpi_context
);
3060 static void dump_set_window_info_request( const struct set_window_info_request
*req
)
3062 fprintf( stderr
, " flags=%04x", req
->flags
);
3063 fprintf( stderr
, ", is_unicode=%d", req
->is_unicode
);
3064 fprintf( stderr
, ", handle=%08x", req
->handle
);
3065 fprintf( stderr
, ", style=%08x", req
->style
);
3066 fprintf( stderr
, ", ex_style=%08x", req
->ex_style
);
3067 fprintf( stderr
, ", extra_size=%u", req
->extra_size
);
3068 dump_uint64( ", instance=", &req
->instance
);
3069 dump_uint64( ", user_data=", &req
->user_data
);
3070 dump_uint64( ", extra_value=", &req
->extra_value
);
3071 fprintf( stderr
, ", extra_offset=%d", req
->extra_offset
);
3074 static void dump_set_window_info_reply( const struct set_window_info_reply
*req
)
3076 fprintf( stderr
, " old_style=%08x", req
->old_style
);
3077 fprintf( stderr
, ", old_ex_style=%08x", req
->old_ex_style
);
3078 dump_uint64( ", old_instance=", &req
->old_instance
);
3079 dump_uint64( ", old_user_data=", &req
->old_user_data
);
3080 dump_uint64( ", old_extra_value=", &req
->old_extra_value
);
3081 dump_uint64( ", old_id=", &req
->old_id
);
3084 static void dump_set_parent_request( const struct set_parent_request
*req
)
3086 fprintf( stderr
, " handle=%08x", req
->handle
);
3087 fprintf( stderr
, ", parent=%08x", req
->parent
);
3090 static void dump_set_parent_reply( const struct set_parent_reply
*req
)
3092 fprintf( stderr
, " old_parent=%08x", req
->old_parent
);
3093 fprintf( stderr
, ", full_parent=%08x", req
->full_parent
);
3094 fprintf( stderr
, ", dpi_context=%08x", req
->dpi_context
);
3097 static void dump_get_window_parents_request( const struct get_window_parents_request
*req
)
3099 fprintf( stderr
, " handle=%08x", req
->handle
);
3102 static void dump_get_window_parents_reply( const struct get_window_parents_reply
*req
)
3104 fprintf( stderr
, " count=%d", req
->count
);
3105 dump_varargs_user_handles( ", parents=", cur_size
);
3108 static void dump_get_window_children_request( const struct get_window_children_request
*req
)
3110 fprintf( stderr
, " desktop=%04x", req
->desktop
);
3111 fprintf( stderr
, ", parent=%08x", req
->parent
);
3112 fprintf( stderr
, ", atom=%04x", req
->atom
);
3113 fprintf( stderr
, ", tid=%04x", req
->tid
);
3114 dump_varargs_unicode_str( ", class=", cur_size
);
3117 static void dump_get_window_children_reply( const struct get_window_children_reply
*req
)
3119 fprintf( stderr
, " count=%d", req
->count
);
3120 dump_varargs_user_handles( ", children=", cur_size
);
3123 static void dump_get_window_children_from_point_request( const struct get_window_children_from_point_request
*req
)
3125 fprintf( stderr
, " parent=%08x", req
->parent
);
3126 fprintf( stderr
, ", x=%d", req
->x
);
3127 fprintf( stderr
, ", y=%d", req
->y
);
3128 fprintf( stderr
, ", dpi=%d", req
->dpi
);
3131 static void dump_get_window_children_from_point_reply( const struct get_window_children_from_point_reply
*req
)
3133 fprintf( stderr
, " count=%d", req
->count
);
3134 dump_varargs_user_handles( ", children=", cur_size
);
3137 static void dump_get_window_tree_request( const struct get_window_tree_request
*req
)
3139 fprintf( stderr
, " handle=%08x", req
->handle
);
3142 static void dump_get_window_tree_reply( const struct get_window_tree_reply
*req
)
3144 fprintf( stderr
, " parent=%08x", req
->parent
);
3145 fprintf( stderr
, ", owner=%08x", req
->owner
);
3146 fprintf( stderr
, ", next_sibling=%08x", req
->next_sibling
);
3147 fprintf( stderr
, ", prev_sibling=%08x", req
->prev_sibling
);
3148 fprintf( stderr
, ", first_sibling=%08x", req
->first_sibling
);
3149 fprintf( stderr
, ", last_sibling=%08x", req
->last_sibling
);
3150 fprintf( stderr
, ", first_child=%08x", req
->first_child
);
3151 fprintf( stderr
, ", last_child=%08x", req
->last_child
);
3154 static void dump_set_window_pos_request( const struct set_window_pos_request
*req
)
3156 fprintf( stderr
, " swp_flags=%04x", req
->swp_flags
);
3157 fprintf( stderr
, ", paint_flags=%04x", req
->paint_flags
);
3158 fprintf( stderr
, ", handle=%08x", req
->handle
);
3159 fprintf( stderr
, ", previous=%08x", req
->previous
);
3160 dump_rectangle( ", window=", &req
->window
);
3161 dump_rectangle( ", client=", &req
->client
);
3162 dump_varargs_rectangles( ", valid=", cur_size
);
3165 static void dump_set_window_pos_reply( const struct set_window_pos_reply
*req
)
3167 fprintf( stderr
, " new_style=%08x", req
->new_style
);
3168 fprintf( stderr
, ", new_ex_style=%08x", req
->new_ex_style
);
3169 fprintf( stderr
, ", surface_win=%08x", req
->surface_win
);
3170 fprintf( stderr
, ", needs_update=%d", req
->needs_update
);
3173 static void dump_get_window_rectangles_request( const struct get_window_rectangles_request
*req
)
3175 fprintf( stderr
, " handle=%08x", req
->handle
);
3176 fprintf( stderr
, ", relative=%d", req
->relative
);
3177 fprintf( stderr
, ", dpi=%d", req
->dpi
);
3180 static void dump_get_window_rectangles_reply( const struct get_window_rectangles_reply
*req
)
3182 dump_rectangle( " window=", &req
->window
);
3183 dump_rectangle( ", client=", &req
->client
);
3186 static void dump_get_window_text_request( const struct get_window_text_request
*req
)
3188 fprintf( stderr
, " handle=%08x", req
->handle
);
3191 static void dump_get_window_text_reply( const struct get_window_text_reply
*req
)
3193 fprintf( stderr
, " length=%u", req
->length
);
3194 dump_varargs_unicode_str( ", text=", cur_size
);
3197 static void dump_set_window_text_request( const struct set_window_text_request
*req
)
3199 fprintf( stderr
, " handle=%08x", req
->handle
);
3200 dump_varargs_unicode_str( ", text=", cur_size
);
3203 static void dump_get_windows_offset_request( const struct get_windows_offset_request
*req
)
3205 fprintf( stderr
, " from=%08x", req
->from
);
3206 fprintf( stderr
, ", to=%08x", req
->to
);
3207 fprintf( stderr
, ", dpi=%d", req
->dpi
);
3210 static void dump_get_windows_offset_reply( const struct get_windows_offset_reply
*req
)
3212 fprintf( stderr
, " x=%d", req
->x
);
3213 fprintf( stderr
, ", y=%d", req
->y
);
3214 fprintf( stderr
, ", mirror=%d", req
->mirror
);
3217 static void dump_get_visible_region_request( const struct get_visible_region_request
*req
)
3219 fprintf( stderr
, " window=%08x", req
->window
);
3220 fprintf( stderr
, ", flags=%08x", req
->flags
);
3223 static void dump_get_visible_region_reply( const struct get_visible_region_reply
*req
)
3225 fprintf( stderr
, " top_win=%08x", req
->top_win
);
3226 dump_rectangle( ", top_rect=", &req
->top_rect
);
3227 dump_rectangle( ", win_rect=", &req
->win_rect
);
3228 fprintf( stderr
, ", paint_flags=%08x", req
->paint_flags
);
3229 fprintf( stderr
, ", total_size=%u", req
->total_size
);
3230 dump_varargs_rectangles( ", region=", cur_size
);
3233 static void dump_get_window_region_request( const struct get_window_region_request
*req
)
3235 fprintf( stderr
, " window=%08x", req
->window
);
3236 fprintf( stderr
, ", surface=%d", req
->surface
);
3239 static void dump_get_window_region_reply( const struct get_window_region_reply
*req
)
3241 dump_rectangle( " visible_rect=", &req
->visible_rect
);
3242 fprintf( stderr
, ", total_size=%u", req
->total_size
);
3243 dump_varargs_rectangles( ", region=", cur_size
);
3246 static void dump_set_window_region_request( const struct set_window_region_request
*req
)
3248 fprintf( stderr
, " window=%08x", req
->window
);
3249 fprintf( stderr
, ", redraw=%d", req
->redraw
);
3250 dump_varargs_rectangles( ", region=", cur_size
);
3253 static void dump_get_update_region_request( const struct get_update_region_request
*req
)
3255 fprintf( stderr
, " window=%08x", req
->window
);
3256 fprintf( stderr
, ", from_child=%08x", req
->from_child
);
3257 fprintf( stderr
, ", flags=%08x", req
->flags
);
3260 static void dump_get_update_region_reply( const struct get_update_region_reply
*req
)
3262 fprintf( stderr
, " child=%08x", req
->child
);
3263 fprintf( stderr
, ", flags=%08x", req
->flags
);
3264 fprintf( stderr
, ", total_size=%u", req
->total_size
);
3265 dump_varargs_rectangles( ", region=", cur_size
);
3268 static void dump_update_window_zorder_request( const struct update_window_zorder_request
*req
)
3270 fprintf( stderr
, " window=%08x", req
->window
);
3271 dump_rectangle( ", rect=", &req
->rect
);
3274 static void dump_redraw_window_request( const struct redraw_window_request
*req
)
3276 fprintf( stderr
, " window=%08x", req
->window
);
3277 fprintf( stderr
, ", flags=%08x", req
->flags
);
3278 dump_varargs_rectangles( ", region=", cur_size
);
3281 static void dump_set_window_property_request( const struct set_window_property_request
*req
)
3283 fprintf( stderr
, " window=%08x", req
->window
);
3284 dump_uint64( ", data=", &req
->data
);
3285 fprintf( stderr
, ", atom=%04x", req
->atom
);
3286 dump_varargs_unicode_str( ", name=", cur_size
);
3289 static void dump_remove_window_property_request( const struct remove_window_property_request
*req
)
3291 fprintf( stderr
, " window=%08x", req
->window
);
3292 fprintf( stderr
, ", atom=%04x", req
->atom
);
3293 dump_varargs_unicode_str( ", name=", cur_size
);
3296 static void dump_remove_window_property_reply( const struct remove_window_property_reply
*req
)
3298 dump_uint64( " data=", &req
->data
);
3301 static void dump_get_window_property_request( const struct get_window_property_request
*req
)
3303 fprintf( stderr
, " window=%08x", req
->window
);
3304 fprintf( stderr
, ", atom=%04x", req
->atom
);
3305 dump_varargs_unicode_str( ", name=", cur_size
);
3308 static void dump_get_window_property_reply( const struct get_window_property_reply
*req
)
3310 dump_uint64( " data=", &req
->data
);
3313 static void dump_get_window_properties_request( const struct get_window_properties_request
*req
)
3315 fprintf( stderr
, " window=%08x", req
->window
);
3318 static void dump_get_window_properties_reply( const struct get_window_properties_reply
*req
)
3320 fprintf( stderr
, " total=%d", req
->total
);
3321 dump_varargs_properties( ", props=", cur_size
);
3324 static void dump_create_winstation_request( const struct create_winstation_request
*req
)
3326 fprintf( stderr
, " flags=%08x", req
->flags
);
3327 fprintf( stderr
, ", access=%08x", req
->access
);
3328 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3329 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
3330 dump_varargs_unicode_str( ", name=", cur_size
);
3333 static void dump_create_winstation_reply( const struct create_winstation_reply
*req
)
3335 fprintf( stderr
, " handle=%04x", req
->handle
);
3338 static void dump_open_winstation_request( const struct open_winstation_request
*req
)
3340 fprintf( stderr
, " access=%08x", req
->access
);
3341 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3342 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
3343 dump_varargs_unicode_str( ", name=", cur_size
);
3346 static void dump_open_winstation_reply( const struct open_winstation_reply
*req
)
3348 fprintf( stderr
, " handle=%04x", req
->handle
);
3351 static void dump_close_winstation_request( const struct close_winstation_request
*req
)
3353 fprintf( stderr
, " handle=%04x", req
->handle
);
3356 static void dump_get_process_winstation_request( const struct get_process_winstation_request
*req
)
3360 static void dump_get_process_winstation_reply( const struct get_process_winstation_reply
*req
)
3362 fprintf( stderr
, " handle=%04x", req
->handle
);
3365 static void dump_set_process_winstation_request( const struct set_process_winstation_request
*req
)
3367 fprintf( stderr
, " handle=%04x", req
->handle
);
3370 static void dump_enum_winstation_request( const struct enum_winstation_request
*req
)
3372 fprintf( stderr
, " index=%08x", req
->index
);
3375 static void dump_enum_winstation_reply( const struct enum_winstation_reply
*req
)
3377 fprintf( stderr
, " next=%08x", req
->next
);
3378 dump_varargs_unicode_str( ", name=", cur_size
);
3381 static void dump_create_desktop_request( const struct create_desktop_request
*req
)
3383 fprintf( stderr
, " flags=%08x", req
->flags
);
3384 fprintf( stderr
, ", access=%08x", req
->access
);
3385 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3386 dump_varargs_unicode_str( ", name=", cur_size
);
3389 static void dump_create_desktop_reply( const struct create_desktop_reply
*req
)
3391 fprintf( stderr
, " handle=%04x", req
->handle
);
3394 static void dump_open_desktop_request( const struct open_desktop_request
*req
)
3396 fprintf( stderr
, " winsta=%04x", req
->winsta
);
3397 fprintf( stderr
, ", flags=%08x", req
->flags
);
3398 fprintf( stderr
, ", access=%08x", req
->access
);
3399 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3400 dump_varargs_unicode_str( ", name=", cur_size
);
3403 static void dump_open_desktop_reply( const struct open_desktop_reply
*req
)
3405 fprintf( stderr
, " handle=%04x", req
->handle
);
3408 static void dump_open_input_desktop_request( const struct open_input_desktop_request
*req
)
3410 fprintf( stderr
, " flags=%08x", req
->flags
);
3411 fprintf( stderr
, ", access=%08x", req
->access
);
3412 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3415 static void dump_open_input_desktop_reply( const struct open_input_desktop_reply
*req
)
3417 fprintf( stderr
, " handle=%04x", req
->handle
);
3420 static void dump_set_input_desktop_request( const struct set_input_desktop_request
*req
)
3422 fprintf( stderr
, " handle=%04x", req
->handle
);
3425 static void dump_close_desktop_request( const struct close_desktop_request
*req
)
3427 fprintf( stderr
, " handle=%04x", req
->handle
);
3430 static void dump_get_thread_desktop_request( const struct get_thread_desktop_request
*req
)
3432 fprintf( stderr
, " tid=%04x", req
->tid
);
3435 static void dump_get_thread_desktop_reply( const struct get_thread_desktop_reply
*req
)
3437 dump_obj_locator( " locator=", &req
->locator
);
3438 fprintf( stderr
, ", handle=%04x", req
->handle
);
3441 static void dump_set_thread_desktop_request( const struct set_thread_desktop_request
*req
)
3443 fprintf( stderr
, " handle=%04x", req
->handle
);
3446 static void dump_set_thread_desktop_reply( const struct set_thread_desktop_reply
*req
)
3448 dump_obj_locator( " locator=", &req
->locator
);
3451 static void dump_enum_desktop_request( const struct enum_desktop_request
*req
)
3453 fprintf( stderr
, " winstation=%04x", req
->winstation
);
3454 fprintf( stderr
, ", index=%08x", req
->index
);
3457 static void dump_enum_desktop_reply( const struct enum_desktop_reply
*req
)
3459 fprintf( stderr
, " next=%08x", req
->next
);
3460 dump_varargs_unicode_str( ", name=", cur_size
);
3463 static void dump_set_user_object_info_request( const struct set_user_object_info_request
*req
)
3465 fprintf( stderr
, " handle=%04x", req
->handle
);
3466 fprintf( stderr
, ", flags=%08x", req
->flags
);
3467 fprintf( stderr
, ", obj_flags=%08x", req
->obj_flags
);
3470 static void dump_set_user_object_info_reply( const struct set_user_object_info_reply
*req
)
3472 fprintf( stderr
, " is_desktop=%d", req
->is_desktop
);
3473 fprintf( stderr
, ", old_obj_flags=%08x", req
->old_obj_flags
);
3474 dump_varargs_unicode_str( ", name=", cur_size
);
3477 static void dump_register_hotkey_request( const struct register_hotkey_request
*req
)
3479 fprintf( stderr
, " window=%08x", req
->window
);
3480 fprintf( stderr
, ", id=%d", req
->id
);
3481 fprintf( stderr
, ", flags=%08x", req
->flags
);
3482 fprintf( stderr
, ", vkey=%08x", req
->vkey
);
3485 static void dump_register_hotkey_reply( const struct register_hotkey_reply
*req
)
3487 fprintf( stderr
, " replaced=%d", req
->replaced
);
3488 fprintf( stderr
, ", flags=%08x", req
->flags
);
3489 fprintf( stderr
, ", vkey=%08x", req
->vkey
);
3492 static void dump_unregister_hotkey_request( const struct unregister_hotkey_request
*req
)
3494 fprintf( stderr
, " window=%08x", req
->window
);
3495 fprintf( stderr
, ", id=%d", req
->id
);
3498 static void dump_unregister_hotkey_reply( const struct unregister_hotkey_reply
*req
)
3500 fprintf( stderr
, " flags=%08x", req
->flags
);
3501 fprintf( stderr
, ", vkey=%08x", req
->vkey
);
3504 static void dump_attach_thread_input_request( const struct attach_thread_input_request
*req
)
3506 fprintf( stderr
, " tid_from=%04x", req
->tid_from
);
3507 fprintf( stderr
, ", tid_to=%04x", req
->tid_to
);
3508 fprintf( stderr
, ", attach=%d", req
->attach
);
3511 static void dump_get_thread_input_request( const struct get_thread_input_request
*req
)
3513 fprintf( stderr
, " tid=%04x", req
->tid
);
3516 static void dump_get_thread_input_reply( const struct get_thread_input_reply
*req
)
3518 fprintf( stderr
, " focus=%08x", req
->focus
);
3519 fprintf( stderr
, ", capture=%08x", req
->capture
);
3520 fprintf( stderr
, ", active=%08x", req
->active
);
3521 fprintf( stderr
, ", foreground=%08x", req
->foreground
);
3522 fprintf( stderr
, ", menu_owner=%08x", req
->menu_owner
);
3523 fprintf( stderr
, ", move_size=%08x", req
->move_size
);
3524 fprintf( stderr
, ", caret=%08x", req
->caret
);
3525 fprintf( stderr
, ", cursor=%08x", req
->cursor
);
3526 fprintf( stderr
, ", show_count=%d", req
->show_count
);
3527 dump_rectangle( ", rect=", &req
->rect
);
3530 static void dump_get_last_input_time_request( const struct get_last_input_time_request
*req
)
3534 static void dump_get_last_input_time_reply( const struct get_last_input_time_reply
*req
)
3536 fprintf( stderr
, " time=%08x", req
->time
);
3539 static void dump_get_key_state_request( const struct get_key_state_request
*req
)
3541 fprintf( stderr
, " async=%d", req
->async
);
3542 fprintf( stderr
, ", key=%d", req
->key
);
3545 static void dump_get_key_state_reply( const struct get_key_state_reply
*req
)
3547 fprintf( stderr
, " state=%02x", req
->state
);
3548 dump_varargs_bytes( ", keystate=", cur_size
);
3551 static void dump_set_key_state_request( const struct set_key_state_request
*req
)
3553 fprintf( stderr
, " async=%d", req
->async
);
3554 dump_varargs_bytes( ", keystate=", cur_size
);
3557 static void dump_set_foreground_window_request( const struct set_foreground_window_request
*req
)
3559 fprintf( stderr
, " handle=%08x", req
->handle
);
3562 static void dump_set_foreground_window_reply( const struct set_foreground_window_reply
*req
)
3564 fprintf( stderr
, " previous=%08x", req
->previous
);
3565 fprintf( stderr
, ", send_msg_old=%d", req
->send_msg_old
);
3566 fprintf( stderr
, ", send_msg_new=%d", req
->send_msg_new
);
3569 static void dump_set_focus_window_request( const struct set_focus_window_request
*req
)
3571 fprintf( stderr
, " handle=%08x", req
->handle
);
3574 static void dump_set_focus_window_reply( const struct set_focus_window_reply
*req
)
3576 fprintf( stderr
, " previous=%08x", req
->previous
);
3579 static void dump_set_active_window_request( const struct set_active_window_request
*req
)
3581 fprintf( stderr
, " handle=%08x", req
->handle
);
3584 static void dump_set_active_window_reply( const struct set_active_window_reply
*req
)
3586 fprintf( stderr
, " previous=%08x", req
->previous
);
3589 static void dump_set_capture_window_request( const struct set_capture_window_request
*req
)
3591 fprintf( stderr
, " handle=%08x", req
->handle
);
3592 fprintf( stderr
, ", flags=%08x", req
->flags
);
3595 static void dump_set_capture_window_reply( const struct set_capture_window_reply
*req
)
3597 fprintf( stderr
, " previous=%08x", req
->previous
);
3598 fprintf( stderr
, ", full_handle=%08x", req
->full_handle
);
3601 static void dump_set_caret_window_request( const struct set_caret_window_request
*req
)
3603 fprintf( stderr
, " handle=%08x", req
->handle
);
3604 fprintf( stderr
, ", width=%d", req
->width
);
3605 fprintf( stderr
, ", height=%d", req
->height
);
3608 static void dump_set_caret_window_reply( const struct set_caret_window_reply
*req
)
3610 fprintf( stderr
, " previous=%08x", req
->previous
);
3611 dump_rectangle( ", old_rect=", &req
->old_rect
);
3612 fprintf( stderr
, ", old_hide=%d", req
->old_hide
);
3613 fprintf( stderr
, ", old_state=%d", req
->old_state
);
3616 static void dump_set_caret_info_request( const struct set_caret_info_request
*req
)
3618 fprintf( stderr
, " flags=%08x", req
->flags
);
3619 fprintf( stderr
, ", handle=%08x", req
->handle
);
3620 fprintf( stderr
, ", x=%d", req
->x
);
3621 fprintf( stderr
, ", y=%d", req
->y
);
3622 fprintf( stderr
, ", hide=%d", req
->hide
);
3623 fprintf( stderr
, ", state=%d", req
->state
);
3626 static void dump_set_caret_info_reply( const struct set_caret_info_reply
*req
)
3628 fprintf( stderr
, " full_handle=%08x", req
->full_handle
);
3629 dump_rectangle( ", old_rect=", &req
->old_rect
);
3630 fprintf( stderr
, ", old_hide=%d", req
->old_hide
);
3631 fprintf( stderr
, ", old_state=%d", req
->old_state
);
3634 static void dump_set_hook_request( const struct set_hook_request
*req
)
3636 fprintf( stderr
, " id=%d", req
->id
);
3637 fprintf( stderr
, ", pid=%04x", req
->pid
);
3638 fprintf( stderr
, ", tid=%04x", req
->tid
);
3639 fprintf( stderr
, ", event_min=%d", req
->event_min
);
3640 fprintf( stderr
, ", event_max=%d", req
->event_max
);
3641 dump_uint64( ", proc=", &req
->proc
);
3642 fprintf( stderr
, ", flags=%d", req
->flags
);
3643 fprintf( stderr
, ", unicode=%d", req
->unicode
);
3644 dump_varargs_unicode_str( ", module=", cur_size
);
3647 static void dump_set_hook_reply( const struct set_hook_reply
*req
)
3649 fprintf( stderr
, " handle=%08x", req
->handle
);
3650 fprintf( stderr
, ", active_hooks=%08x", req
->active_hooks
);
3653 static void dump_remove_hook_request( const struct remove_hook_request
*req
)
3655 fprintf( stderr
, " handle=%08x", req
->handle
);
3656 dump_uint64( ", proc=", &req
->proc
);
3657 fprintf( stderr
, ", id=%d", req
->id
);
3660 static void dump_remove_hook_reply( const struct remove_hook_reply
*req
)
3662 fprintf( stderr
, " active_hooks=%08x", req
->active_hooks
);
3665 static void dump_start_hook_chain_request( const struct start_hook_chain_request
*req
)
3667 fprintf( stderr
, " id=%d", req
->id
);
3668 fprintf( stderr
, ", event=%d", req
->event
);
3669 fprintf( stderr
, ", window=%08x", req
->window
);
3670 fprintf( stderr
, ", object_id=%d", req
->object_id
);
3671 fprintf( stderr
, ", child_id=%d", req
->child_id
);
3674 static void dump_start_hook_chain_reply( const struct start_hook_chain_reply
*req
)
3676 fprintf( stderr
, " handle=%08x", req
->handle
);
3677 fprintf( stderr
, ", pid=%04x", req
->pid
);
3678 fprintf( stderr
, ", tid=%04x", req
->tid
);
3679 fprintf( stderr
, ", unicode=%d", req
->unicode
);
3680 dump_uint64( ", proc=", &req
->proc
);
3681 fprintf( stderr
, ", active_hooks=%08x", req
->active_hooks
);
3682 dump_varargs_unicode_str( ", module=", cur_size
);
3685 static void dump_finish_hook_chain_request( const struct finish_hook_chain_request
*req
)
3687 fprintf( stderr
, " id=%d", req
->id
);
3690 static void dump_get_hook_info_request( const struct get_hook_info_request
*req
)
3692 fprintf( stderr
, " handle=%08x", req
->handle
);
3693 fprintf( stderr
, ", get_next=%d", req
->get_next
);
3694 fprintf( stderr
, ", event=%d", req
->event
);
3695 fprintf( stderr
, ", window=%08x", req
->window
);
3696 fprintf( stderr
, ", object_id=%d", req
->object_id
);
3697 fprintf( stderr
, ", child_id=%d", req
->child_id
);
3700 static void dump_get_hook_info_reply( const struct get_hook_info_reply
*req
)
3702 fprintf( stderr
, " handle=%08x", req
->handle
);
3703 fprintf( stderr
, ", id=%d", req
->id
);
3704 fprintf( stderr
, ", pid=%04x", req
->pid
);
3705 fprintf( stderr
, ", tid=%04x", req
->tid
);
3706 dump_uint64( ", proc=", &req
->proc
);
3707 fprintf( stderr
, ", unicode=%d", req
->unicode
);
3708 dump_varargs_unicode_str( ", module=", cur_size
);
3711 static void dump_create_class_request( const struct create_class_request
*req
)
3713 fprintf( stderr
, " local=%d", req
->local
);
3714 fprintf( stderr
, ", atom=%04x", req
->atom
);
3715 fprintf( stderr
, ", style=%08x", req
->style
);
3716 dump_uint64( ", instance=", &req
->instance
);
3717 fprintf( stderr
, ", extra=%d", req
->extra
);
3718 fprintf( stderr
, ", win_extra=%d", req
->win_extra
);
3719 dump_uint64( ", client_ptr=", &req
->client_ptr
);
3720 fprintf( stderr
, ", name_offset=%u", req
->name_offset
);
3721 dump_varargs_unicode_str( ", name=", cur_size
);
3724 static void dump_create_class_reply( const struct create_class_reply
*req
)
3726 fprintf( stderr
, " atom=%04x", req
->atom
);
3729 static void dump_destroy_class_request( const struct destroy_class_request
*req
)
3731 fprintf( stderr
, " atom=%04x", req
->atom
);
3732 dump_uint64( ", instance=", &req
->instance
);
3733 dump_varargs_unicode_str( ", name=", cur_size
);
3736 static void dump_destroy_class_reply( const struct destroy_class_reply
*req
)
3738 dump_uint64( " client_ptr=", &req
->client_ptr
);
3741 static void dump_set_class_info_request( const struct set_class_info_request
*req
)
3743 fprintf( stderr
, " window=%08x", req
->window
);
3744 fprintf( stderr
, ", flags=%08x", req
->flags
);
3745 fprintf( stderr
, ", atom=%04x", req
->atom
);
3746 fprintf( stderr
, ", style=%08x", req
->style
);
3747 fprintf( stderr
, ", win_extra=%d", req
->win_extra
);
3748 dump_uint64( ", instance=", &req
->instance
);
3749 fprintf( stderr
, ", extra_offset=%d", req
->extra_offset
);
3750 fprintf( stderr
, ", extra_size=%u", req
->extra_size
);
3751 dump_uint64( ", extra_value=", &req
->extra_value
);
3754 static void dump_set_class_info_reply( const struct set_class_info_reply
*req
)
3756 fprintf( stderr
, " old_atom=%04x", req
->old_atom
);
3757 fprintf( stderr
, ", base_atom=%04x", req
->base_atom
);
3758 dump_uint64( ", old_instance=", &req
->old_instance
);
3759 dump_uint64( ", old_extra_value=", &req
->old_extra_value
);
3760 fprintf( stderr
, ", old_style=%08x", req
->old_style
);
3761 fprintf( stderr
, ", old_extra=%d", req
->old_extra
);
3762 fprintf( stderr
, ", old_win_extra=%d", req
->old_win_extra
);
3765 static void dump_open_clipboard_request( const struct open_clipboard_request
*req
)
3767 fprintf( stderr
, " window=%08x", req
->window
);
3770 static void dump_open_clipboard_reply( const struct open_clipboard_reply
*req
)
3772 fprintf( stderr
, " owner=%08x", req
->owner
);
3775 static void dump_close_clipboard_request( const struct close_clipboard_request
*req
)
3779 static void dump_close_clipboard_reply( const struct close_clipboard_reply
*req
)
3781 fprintf( stderr
, " viewer=%08x", req
->viewer
);
3782 fprintf( stderr
, ", owner=%08x", req
->owner
);
3785 static void dump_empty_clipboard_request( const struct empty_clipboard_request
*req
)
3789 static void dump_set_clipboard_data_request( const struct set_clipboard_data_request
*req
)
3791 fprintf( stderr
, " format=%08x", req
->format
);
3792 fprintf( stderr
, ", lcid=%08x", req
->lcid
);
3793 dump_varargs_bytes( ", data=", cur_size
);
3796 static void dump_set_clipboard_data_reply( const struct set_clipboard_data_reply
*req
)
3798 fprintf( stderr
, " seqno=%08x", req
->seqno
);
3801 static void dump_get_clipboard_data_request( const struct get_clipboard_data_request
*req
)
3803 fprintf( stderr
, " format=%08x", req
->format
);
3804 fprintf( stderr
, ", render=%d", req
->render
);
3805 fprintf( stderr
, ", cached=%d", req
->cached
);
3806 fprintf( stderr
, ", seqno=%08x", req
->seqno
);
3809 static void dump_get_clipboard_data_reply( const struct get_clipboard_data_reply
*req
)
3811 fprintf( stderr
, " from=%08x", req
->from
);
3812 fprintf( stderr
, ", owner=%08x", req
->owner
);
3813 fprintf( stderr
, ", seqno=%08x", req
->seqno
);
3814 fprintf( stderr
, ", total=%u", req
->total
);
3815 dump_varargs_bytes( ", data=", cur_size
);
3818 static void dump_get_clipboard_formats_request( const struct get_clipboard_formats_request
*req
)
3820 fprintf( stderr
, " format=%08x", req
->format
);
3823 static void dump_get_clipboard_formats_reply( const struct get_clipboard_formats_reply
*req
)
3825 fprintf( stderr
, " count=%08x", req
->count
);
3826 dump_varargs_uints( ", formats=", cur_size
);
3829 static void dump_enum_clipboard_formats_request( const struct enum_clipboard_formats_request
*req
)
3831 fprintf( stderr
, " previous=%08x", req
->previous
);
3834 static void dump_enum_clipboard_formats_reply( const struct enum_clipboard_formats_reply
*req
)
3836 fprintf( stderr
, " format=%08x", req
->format
);
3839 static void dump_release_clipboard_request( const struct release_clipboard_request
*req
)
3841 fprintf( stderr
, " owner=%08x", req
->owner
);
3844 static void dump_release_clipboard_reply( const struct release_clipboard_reply
*req
)
3846 fprintf( stderr
, " viewer=%08x", req
->viewer
);
3847 fprintf( stderr
, ", owner=%08x", req
->owner
);
3850 static void dump_get_clipboard_info_request( const struct get_clipboard_info_request
*req
)
3854 static void dump_get_clipboard_info_reply( const struct get_clipboard_info_reply
*req
)
3856 fprintf( stderr
, " window=%08x", req
->window
);
3857 fprintf( stderr
, ", owner=%08x", req
->owner
);
3858 fprintf( stderr
, ", viewer=%08x", req
->viewer
);
3859 fprintf( stderr
, ", seqno=%08x", req
->seqno
);
3862 static void dump_set_clipboard_viewer_request( const struct set_clipboard_viewer_request
*req
)
3864 fprintf( stderr
, " viewer=%08x", req
->viewer
);
3865 fprintf( stderr
, ", previous=%08x", req
->previous
);
3868 static void dump_set_clipboard_viewer_reply( const struct set_clipboard_viewer_reply
*req
)
3870 fprintf( stderr
, " old_viewer=%08x", req
->old_viewer
);
3871 fprintf( stderr
, ", owner=%08x", req
->owner
);
3874 static void dump_add_clipboard_listener_request( const struct add_clipboard_listener_request
*req
)
3876 fprintf( stderr
, " window=%08x", req
->window
);
3879 static void dump_remove_clipboard_listener_request( const struct remove_clipboard_listener_request
*req
)
3881 fprintf( stderr
, " window=%08x", req
->window
);
3884 static void dump_create_token_request( const struct create_token_request
*req
)
3886 dump_luid( " token_id=", &req
->token_id
);
3887 fprintf( stderr
, ", access=%08x", req
->access
);
3888 fprintf( stderr
, ", primary=%d", req
->primary
);
3889 fprintf( stderr
, ", impersonation_level=%d", req
->impersonation_level
);
3890 dump_abstime( ", expire=", &req
->expire
);
3891 fprintf( stderr
, ", group_count=%d", req
->group_count
);
3892 fprintf( stderr
, ", primary_group=%d", req
->primary_group
);
3893 fprintf( stderr
, ", priv_count=%d", req
->priv_count
);
3896 static void dump_create_token_reply( const struct create_token_reply
*req
)
3898 fprintf( stderr
, " token=%04x", req
->token
);
3901 static void dump_open_token_request( const struct open_token_request
*req
)
3903 fprintf( stderr
, " handle=%04x", req
->handle
);
3904 fprintf( stderr
, ", access=%08x", req
->access
);
3905 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3906 fprintf( stderr
, ", flags=%08x", req
->flags
);
3909 static void dump_open_token_reply( const struct open_token_reply
*req
)
3911 fprintf( stderr
, " token=%04x", req
->token
);
3914 static void dump_set_global_windows_request( const struct set_global_windows_request
*req
)
3916 fprintf( stderr
, " flags=%08x", req
->flags
);
3917 fprintf( stderr
, ", shell_window=%08x", req
->shell_window
);
3918 fprintf( stderr
, ", shell_listview=%08x", req
->shell_listview
);
3919 fprintf( stderr
, ", progman_window=%08x", req
->progman_window
);
3920 fprintf( stderr
, ", taskman_window=%08x", req
->taskman_window
);
3923 static void dump_set_global_windows_reply( const struct set_global_windows_reply
*req
)
3925 fprintf( stderr
, " old_shell_window=%08x", req
->old_shell_window
);
3926 fprintf( stderr
, ", old_shell_listview=%08x", req
->old_shell_listview
);
3927 fprintf( stderr
, ", old_progman_window=%08x", req
->old_progman_window
);
3928 fprintf( stderr
, ", old_taskman_window=%08x", req
->old_taskman_window
);
3931 static void dump_adjust_token_privileges_request( const struct adjust_token_privileges_request
*req
)
3933 fprintf( stderr
, " handle=%04x", req
->handle
);
3934 fprintf( stderr
, ", disable_all=%d", req
->disable_all
);
3935 fprintf( stderr
, ", get_modified_state=%d", req
->get_modified_state
);
3936 dump_varargs_luid_attr( ", privileges=", cur_size
);
3939 static void dump_adjust_token_privileges_reply( const struct adjust_token_privileges_reply
*req
)
3941 fprintf( stderr
, " len=%08x", req
->len
);
3942 dump_varargs_luid_attr( ", privileges=", cur_size
);
3945 static void dump_get_token_privileges_request( const struct get_token_privileges_request
*req
)
3947 fprintf( stderr
, " handle=%04x", req
->handle
);
3950 static void dump_get_token_privileges_reply( const struct get_token_privileges_reply
*req
)
3952 fprintf( stderr
, " len=%08x", req
->len
);
3953 dump_varargs_luid_attr( ", privileges=", cur_size
);
3956 static void dump_check_token_privileges_request( const struct check_token_privileges_request
*req
)
3958 fprintf( stderr
, " handle=%04x", req
->handle
);
3959 fprintf( stderr
, ", all_required=%d", req
->all_required
);
3960 dump_varargs_luid_attr( ", privileges=", cur_size
);
3963 static void dump_check_token_privileges_reply( const struct check_token_privileges_reply
*req
)
3965 fprintf( stderr
, " has_privileges=%d", req
->has_privileges
);
3966 dump_varargs_luid_attr( ", privileges=", cur_size
);
3969 static void dump_duplicate_token_request( const struct duplicate_token_request
*req
)
3971 fprintf( stderr
, " handle=%04x", req
->handle
);
3972 fprintf( stderr
, ", access=%08x", req
->access
);
3973 fprintf( stderr
, ", primary=%d", req
->primary
);
3974 fprintf( stderr
, ", impersonation_level=%d", req
->impersonation_level
);
3975 dump_varargs_object_attributes( ", objattr=", cur_size
);
3978 static void dump_duplicate_token_reply( const struct duplicate_token_reply
*req
)
3980 fprintf( stderr
, " new_handle=%04x", req
->new_handle
);
3983 static void dump_filter_token_request( const struct filter_token_request
*req
)
3985 fprintf( stderr
, " handle=%04x", req
->handle
);
3986 fprintf( stderr
, ", flags=%08x", req
->flags
);
3987 fprintf( stderr
, ", privileges_size=%u", req
->privileges_size
);
3988 dump_varargs_luid_attr( ", privileges=", min(cur_size
,req
->privileges_size
) );
3989 dump_varargs_sid( ", disable_sids=", cur_size
);
3992 static void dump_filter_token_reply( const struct filter_token_reply
*req
)
3994 fprintf( stderr
, " new_handle=%04x", req
->new_handle
);
3997 static void dump_access_check_request( const struct access_check_request
*req
)
3999 fprintf( stderr
, " handle=%04x", req
->handle
);
4000 fprintf( stderr
, ", desired_access=%08x", req
->desired_access
);
4001 dump_generic_map( ", mapping=", &req
->mapping
);
4002 dump_varargs_security_descriptor( ", sd=", cur_size
);
4005 static void dump_access_check_reply( const struct access_check_reply
*req
)
4007 fprintf( stderr
, " access_granted=%08x", req
->access_granted
);
4008 fprintf( stderr
, ", access_status=%08x", req
->access_status
);
4009 fprintf( stderr
, ", privileges_len=%08x", req
->privileges_len
);
4010 dump_varargs_luid_attr( ", privileges=", cur_size
);
4013 static void dump_get_token_sid_request( const struct get_token_sid_request
*req
)
4015 fprintf( stderr
, " handle=%04x", req
->handle
);
4016 fprintf( stderr
, ", which_sid=%08x", req
->which_sid
);
4019 static void dump_get_token_sid_reply( const struct get_token_sid_reply
*req
)
4021 fprintf( stderr
, " sid_len=%u", req
->sid_len
);
4022 dump_varargs_sid( ", sid=", cur_size
);
4025 static void dump_get_token_groups_request( const struct get_token_groups_request
*req
)
4027 fprintf( stderr
, " handle=%04x", req
->handle
);
4028 fprintf( stderr
, ", attr_mask=%08x", req
->attr_mask
);
4031 static void dump_get_token_groups_reply( const struct get_token_groups_reply
*req
)
4033 fprintf( stderr
, " attr_len=%u", req
->attr_len
);
4034 fprintf( stderr
, ", sid_len=%u", req
->sid_len
);
4035 dump_varargs_uints( ", attrs=", min(cur_size
,req
->attr_len
) );
4036 dump_varargs_sids( ", sids=", cur_size
);
4039 static void dump_get_token_default_dacl_request( const struct get_token_default_dacl_request
*req
)
4041 fprintf( stderr
, " handle=%04x", req
->handle
);
4044 static void dump_get_token_default_dacl_reply( const struct get_token_default_dacl_reply
*req
)
4046 fprintf( stderr
, " acl_len=%u", req
->acl_len
);
4047 dump_varargs_acl( ", acl=", cur_size
);
4050 static void dump_set_token_default_dacl_request( const struct set_token_default_dacl_request
*req
)
4052 fprintf( stderr
, " handle=%04x", req
->handle
);
4053 dump_varargs_acl( ", acl=", cur_size
);
4056 static void dump_set_security_object_request( const struct set_security_object_request
*req
)
4058 fprintf( stderr
, " handle=%04x", req
->handle
);
4059 fprintf( stderr
, ", security_info=%08x", req
->security_info
);
4060 dump_varargs_security_descriptor( ", sd=", cur_size
);
4063 static void dump_get_security_object_request( const struct get_security_object_request
*req
)
4065 fprintf( stderr
, " handle=%04x", req
->handle
);
4066 fprintf( stderr
, ", security_info=%08x", req
->security_info
);
4069 static void dump_get_security_object_reply( const struct get_security_object_reply
*req
)
4071 fprintf( stderr
, " sd_len=%08x", req
->sd_len
);
4072 dump_varargs_security_descriptor( ", sd=", cur_size
);
4075 static void dump_get_system_handles_request( const struct get_system_handles_request
*req
)
4079 static void dump_get_system_handles_reply( const struct get_system_handles_reply
*req
)
4081 fprintf( stderr
, " count=%08x", req
->count
);
4082 dump_varargs_handle_infos( ", data=", cur_size
);
4085 static void dump_create_mailslot_request( const struct create_mailslot_request
*req
)
4087 fprintf( stderr
, " access=%08x", req
->access
);
4088 dump_timeout( ", read_timeout=", &req
->read_timeout
);
4089 fprintf( stderr
, ", max_msgsize=%08x", req
->max_msgsize
);
4090 dump_varargs_object_attributes( ", objattr=", cur_size
);
4093 static void dump_create_mailslot_reply( const struct create_mailslot_reply
*req
)
4095 fprintf( stderr
, " handle=%04x", req
->handle
);
4098 static void dump_set_mailslot_info_request( const struct set_mailslot_info_request
*req
)
4100 fprintf( stderr
, " handle=%04x", req
->handle
);
4101 dump_timeout( ", read_timeout=", &req
->read_timeout
);
4102 fprintf( stderr
, ", flags=%08x", req
->flags
);
4105 static void dump_set_mailslot_info_reply( const struct set_mailslot_info_reply
*req
)
4107 dump_timeout( " read_timeout=", &req
->read_timeout
);
4108 fprintf( stderr
, ", max_msgsize=%08x", req
->max_msgsize
);
4111 static void dump_create_directory_request( const struct create_directory_request
*req
)
4113 fprintf( stderr
, " access=%08x", req
->access
);
4114 dump_varargs_object_attributes( ", objattr=", cur_size
);
4117 static void dump_create_directory_reply( const struct create_directory_reply
*req
)
4119 fprintf( stderr
, " handle=%04x", req
->handle
);
4122 static void dump_open_directory_request( const struct open_directory_request
*req
)
4124 fprintf( stderr
, " access=%08x", req
->access
);
4125 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
4126 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
4127 dump_varargs_unicode_str( ", directory_name=", cur_size
);
4130 static void dump_open_directory_reply( const struct open_directory_reply
*req
)
4132 fprintf( stderr
, " handle=%04x", req
->handle
);
4135 static void dump_get_directory_entries_request( const struct get_directory_entries_request
*req
)
4137 fprintf( stderr
, " handle=%04x", req
->handle
);
4138 fprintf( stderr
, ", index=%08x", req
->index
);
4139 fprintf( stderr
, ", max_count=%08x", req
->max_count
);
4142 static void dump_get_directory_entries_reply( const struct get_directory_entries_reply
*req
)
4144 fprintf( stderr
, " total_len=%u", req
->total_len
);
4145 fprintf( stderr
, ", count=%08x", req
->count
);
4146 dump_varargs_directory_entries( ", entries=", cur_size
);
4149 static void dump_create_symlink_request( const struct create_symlink_request
*req
)
4151 fprintf( stderr
, " access=%08x", req
->access
);
4152 dump_varargs_object_attributes( ", objattr=", cur_size
);
4153 dump_varargs_unicode_str( ", target_name=", cur_size
);
4156 static void dump_create_symlink_reply( const struct create_symlink_reply
*req
)
4158 fprintf( stderr
, " handle=%04x", req
->handle
);
4161 static void dump_open_symlink_request( const struct open_symlink_request
*req
)
4163 fprintf( stderr
, " access=%08x", req
->access
);
4164 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
4165 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
4166 dump_varargs_unicode_str( ", name=", cur_size
);
4169 static void dump_open_symlink_reply( const struct open_symlink_reply
*req
)
4171 fprintf( stderr
, " handle=%04x", req
->handle
);
4174 static void dump_query_symlink_request( const struct query_symlink_request
*req
)
4176 fprintf( stderr
, " handle=%04x", req
->handle
);
4179 static void dump_query_symlink_reply( const struct query_symlink_reply
*req
)
4181 fprintf( stderr
, " total=%u", req
->total
);
4182 dump_varargs_unicode_str( ", target_name=", cur_size
);
4185 static void dump_get_object_info_request( const struct get_object_info_request
*req
)
4187 fprintf( stderr
, " handle=%04x", req
->handle
);
4190 static void dump_get_object_info_reply( const struct get_object_info_reply
*req
)
4192 fprintf( stderr
, " access=%08x", req
->access
);
4193 fprintf( stderr
, ", ref_count=%08x", req
->ref_count
);
4194 fprintf( stderr
, ", handle_count=%08x", req
->handle_count
);
4197 static void dump_get_object_name_request( const struct get_object_name_request
*req
)
4199 fprintf( stderr
, " handle=%04x", req
->handle
);
4202 static void dump_get_object_name_reply( const struct get_object_name_reply
*req
)
4204 fprintf( stderr
, " total=%u", req
->total
);
4205 dump_varargs_unicode_str( ", name=", cur_size
);
4208 static void dump_get_object_type_request( const struct get_object_type_request
*req
)
4210 fprintf( stderr
, " handle=%04x", req
->handle
);
4213 static void dump_get_object_type_reply( const struct get_object_type_reply
*req
)
4215 dump_varargs_object_type_info( " info=", cur_size
);
4218 static void dump_get_object_types_request( const struct get_object_types_request
*req
)
4222 static void dump_get_object_types_reply( const struct get_object_types_reply
*req
)
4224 fprintf( stderr
, " count=%d", req
->count
);
4225 dump_varargs_object_types_info( ", info=", cur_size
);
4228 static void dump_allocate_locally_unique_id_request( const struct allocate_locally_unique_id_request
*req
)
4232 static void dump_allocate_locally_unique_id_reply( const struct allocate_locally_unique_id_reply
*req
)
4234 dump_luid( " luid=", &req
->luid
);
4237 static void dump_create_device_manager_request( const struct create_device_manager_request
*req
)
4239 fprintf( stderr
, " access=%08x", req
->access
);
4240 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
4243 static void dump_create_device_manager_reply( const struct create_device_manager_reply
*req
)
4245 fprintf( stderr
, " handle=%04x", req
->handle
);
4248 static void dump_create_device_request( const struct create_device_request
*req
)
4250 fprintf( stderr
, " rootdir=%04x", req
->rootdir
);
4251 dump_uint64( ", user_ptr=", &req
->user_ptr
);
4252 fprintf( stderr
, ", manager=%04x", req
->manager
);
4253 dump_varargs_unicode_str( ", name=", cur_size
);
4256 static void dump_delete_device_request( const struct delete_device_request
*req
)
4258 fprintf( stderr
, " manager=%04x", req
->manager
);
4259 dump_uint64( ", device=", &req
->device
);
4262 static void dump_get_next_device_request_request( const struct get_next_device_request_request
*req
)
4264 fprintf( stderr
, " manager=%04x", req
->manager
);
4265 fprintf( stderr
, ", prev=%04x", req
->prev
);
4266 fprintf( stderr
, ", status=%08x", req
->status
);
4267 dump_uint64( ", user_ptr=", &req
->user_ptr
);
4268 fprintf( stderr
, ", pending=%d", req
->pending
);
4269 fprintf( stderr
, ", iosb_status=%08x", req
->iosb_status
);
4270 fprintf( stderr
, ", result=%u", req
->result
);
4271 dump_varargs_bytes( ", data=", cur_size
);
4274 static void dump_get_next_device_request_reply( const struct get_next_device_request_reply
*req
)
4276 dump_irp_params( " params=", &req
->params
);
4277 fprintf( stderr
, ", next=%04x", req
->next
);
4278 fprintf( stderr
, ", client_tid=%04x", req
->client_tid
);
4279 dump_uint64( ", client_thread=", &req
->client_thread
);
4280 fprintf( stderr
, ", in_size=%u", req
->in_size
);
4281 dump_varargs_bytes( ", next_data=", cur_size
);
4284 static void dump_get_kernel_object_ptr_request( const struct get_kernel_object_ptr_request
*req
)
4286 fprintf( stderr
, " manager=%04x", req
->manager
);
4287 fprintf( stderr
, ", handle=%04x", req
->handle
);
4290 static void dump_get_kernel_object_ptr_reply( const struct get_kernel_object_ptr_reply
*req
)
4292 dump_uint64( " user_ptr=", &req
->user_ptr
);
4295 static void dump_set_kernel_object_ptr_request( const struct set_kernel_object_ptr_request
*req
)
4297 fprintf( stderr
, " manager=%04x", req
->manager
);
4298 fprintf( stderr
, ", handle=%04x", req
->handle
);
4299 dump_uint64( ", user_ptr=", &req
->user_ptr
);
4302 static void dump_grab_kernel_object_request( const struct grab_kernel_object_request
*req
)
4304 fprintf( stderr
, " manager=%04x", req
->manager
);
4305 dump_uint64( ", user_ptr=", &req
->user_ptr
);
4308 static void dump_release_kernel_object_request( const struct release_kernel_object_request
*req
)
4310 fprintf( stderr
, " manager=%04x", req
->manager
);
4311 dump_uint64( ", user_ptr=", &req
->user_ptr
);
4314 static void dump_get_kernel_object_handle_request( const struct get_kernel_object_handle_request
*req
)
4316 fprintf( stderr
, " manager=%04x", req
->manager
);
4317 dump_uint64( ", user_ptr=", &req
->user_ptr
);
4318 fprintf( stderr
, ", access=%08x", req
->access
);
4321 static void dump_get_kernel_object_handle_reply( const struct get_kernel_object_handle_reply
*req
)
4323 fprintf( stderr
, " handle=%04x", req
->handle
);
4326 static void dump_make_process_system_request( const struct make_process_system_request
*req
)
4328 fprintf( stderr
, " handle=%04x", req
->handle
);
4331 static void dump_make_process_system_reply( const struct make_process_system_reply
*req
)
4333 fprintf( stderr
, " event=%04x", req
->event
);
4336 static void dump_get_token_info_request( const struct get_token_info_request
*req
)
4338 fprintf( stderr
, " handle=%04x", req
->handle
);
4341 static void dump_get_token_info_reply( const struct get_token_info_reply
*req
)
4343 dump_luid( " token_id=", &req
->token_id
);
4344 dump_luid( ", modified_id=", &req
->modified_id
);
4345 fprintf( stderr
, ", session_id=%08x", req
->session_id
);
4346 fprintf( stderr
, ", primary=%d", req
->primary
);
4347 fprintf( stderr
, ", impersonation_level=%d", req
->impersonation_level
);
4348 fprintf( stderr
, ", elevation=%d", req
->elevation
);
4349 fprintf( stderr
, ", group_count=%d", req
->group_count
);
4350 fprintf( stderr
, ", privilege_count=%d", req
->privilege_count
);
4353 static void dump_create_linked_token_request( const struct create_linked_token_request
*req
)
4355 fprintf( stderr
, " handle=%04x", req
->handle
);
4358 static void dump_create_linked_token_reply( const struct create_linked_token_reply
*req
)
4360 fprintf( stderr
, " linked=%04x", req
->linked
);
4363 static void dump_create_completion_request( const struct create_completion_request
*req
)
4365 fprintf( stderr
, " access=%08x", req
->access
);
4366 fprintf( stderr
, ", concurrent=%08x", req
->concurrent
);
4367 dump_varargs_object_attributes( ", objattr=", cur_size
);
4370 static void dump_create_completion_reply( const struct create_completion_reply
*req
)
4372 fprintf( stderr
, " handle=%04x", req
->handle
);
4375 static void dump_open_completion_request( const struct open_completion_request
*req
)
4377 fprintf( stderr
, " access=%08x", req
->access
);
4378 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
4379 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
4380 dump_varargs_unicode_str( ", filename=", cur_size
);
4383 static void dump_open_completion_reply( const struct open_completion_reply
*req
)
4385 fprintf( stderr
, " handle=%04x", req
->handle
);
4388 static void dump_add_completion_request( const struct add_completion_request
*req
)
4390 fprintf( stderr
, " handle=%04x", req
->handle
);
4391 dump_uint64( ", ckey=", &req
->ckey
);
4392 dump_uint64( ", cvalue=", &req
->cvalue
);
4393 dump_uint64( ", information=", &req
->information
);
4394 fprintf( stderr
, ", status=%08x", req
->status
);
4397 static void dump_remove_completion_request( const struct remove_completion_request
*req
)
4399 fprintf( stderr
, " handle=%04x", req
->handle
);
4402 static void dump_remove_completion_reply( const struct remove_completion_reply
*req
)
4404 dump_uint64( " ckey=", &req
->ckey
);
4405 dump_uint64( ", cvalue=", &req
->cvalue
);
4406 dump_uint64( ", information=", &req
->information
);
4407 fprintf( stderr
, ", status=%08x", req
->status
);
4410 static void dump_query_completion_request( const struct query_completion_request
*req
)
4412 fprintf( stderr
, " handle=%04x", req
->handle
);
4415 static void dump_query_completion_reply( const struct query_completion_reply
*req
)
4417 fprintf( stderr
, " depth=%08x", req
->depth
);
4420 static void dump_set_completion_info_request( const struct set_completion_info_request
*req
)
4422 fprintf( stderr
, " handle=%04x", req
->handle
);
4423 dump_uint64( ", ckey=", &req
->ckey
);
4424 fprintf( stderr
, ", chandle=%04x", req
->chandle
);
4427 static void dump_add_fd_completion_request( const struct add_fd_completion_request
*req
)
4429 fprintf( stderr
, " handle=%04x", req
->handle
);
4430 dump_uint64( ", cvalue=", &req
->cvalue
);
4431 dump_uint64( ", information=", &req
->information
);
4432 fprintf( stderr
, ", status=%08x", req
->status
);
4433 fprintf( stderr
, ", async=%d", req
->async
);
4436 static void dump_set_fd_completion_mode_request( const struct set_fd_completion_mode_request
*req
)
4438 fprintf( stderr
, " handle=%04x", req
->handle
);
4439 fprintf( stderr
, ", flags=%08x", req
->flags
);
4442 static void dump_set_fd_disp_info_request( const struct set_fd_disp_info_request
*req
)
4444 fprintf( stderr
, " handle=%04x", req
->handle
);
4445 fprintf( stderr
, ", flags=%08x", req
->flags
);
4448 static void dump_set_fd_name_info_request( const struct set_fd_name_info_request
*req
)
4450 fprintf( stderr
, " handle=%04x", req
->handle
);
4451 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
4452 fprintf( stderr
, ", namelen=%u", req
->namelen
);
4453 fprintf( stderr
, ", link=%d", req
->link
);
4454 fprintf( stderr
, ", flags=%08x", req
->flags
);
4455 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->namelen
) );
4456 dump_varargs_string( ", filename=", cur_size
);
4459 static void dump_set_fd_eof_info_request( const struct set_fd_eof_info_request
*req
)
4461 fprintf( stderr
, " handle=%04x", req
->handle
);
4462 dump_uint64( ", eof=", &req
->eof
);
4465 static void dump_get_window_layered_info_request( const struct get_window_layered_info_request
*req
)
4467 fprintf( stderr
, " handle=%08x", req
->handle
);
4470 static void dump_get_window_layered_info_reply( const struct get_window_layered_info_reply
*req
)
4472 fprintf( stderr
, " color_key=%08x", req
->color_key
);
4473 fprintf( stderr
, ", alpha=%08x", req
->alpha
);
4474 fprintf( stderr
, ", flags=%08x", req
->flags
);
4477 static void dump_set_window_layered_info_request( const struct set_window_layered_info_request
*req
)
4479 fprintf( stderr
, " handle=%08x", req
->handle
);
4480 fprintf( stderr
, ", color_key=%08x", req
->color_key
);
4481 fprintf( stderr
, ", alpha=%08x", req
->alpha
);
4482 fprintf( stderr
, ", flags=%08x", req
->flags
);
4485 static void dump_alloc_user_handle_request( const struct alloc_user_handle_request
*req
)
4489 static void dump_alloc_user_handle_reply( const struct alloc_user_handle_reply
*req
)
4491 fprintf( stderr
, " handle=%08x", req
->handle
);
4494 static void dump_free_user_handle_request( const struct free_user_handle_request
*req
)
4496 fprintf( stderr
, " handle=%08x", req
->handle
);
4499 static void dump_set_cursor_request( const struct set_cursor_request
*req
)
4501 fprintf( stderr
, " flags=%08x", req
->flags
);
4502 fprintf( stderr
, ", handle=%08x", req
->handle
);
4503 fprintf( stderr
, ", show_count=%d", req
->show_count
);
4504 fprintf( stderr
, ", x=%d", req
->x
);
4505 fprintf( stderr
, ", y=%d", req
->y
);
4506 dump_rectangle( ", clip=", &req
->clip
);
4509 static void dump_set_cursor_reply( const struct set_cursor_reply
*req
)
4511 fprintf( stderr
, " prev_handle=%08x", req
->prev_handle
);
4512 fprintf( stderr
, ", prev_count=%d", req
->prev_count
);
4513 fprintf( stderr
, ", prev_x=%d", req
->prev_x
);
4514 fprintf( stderr
, ", prev_y=%d", req
->prev_y
);
4515 fprintf( stderr
, ", new_x=%d", req
->new_x
);
4516 fprintf( stderr
, ", new_y=%d", req
->new_y
);
4517 dump_rectangle( ", new_clip=", &req
->new_clip
);
4518 fprintf( stderr
, ", last_change=%08x", req
->last_change
);
4521 static void dump_get_cursor_history_request( const struct get_cursor_history_request
*req
)
4525 static void dump_get_cursor_history_reply( const struct get_cursor_history_reply
*req
)
4527 dump_varargs_cursor_positions( " history=", cur_size
);
4530 static void dump_get_rawinput_buffer_request( const struct get_rawinput_buffer_request
*req
)
4532 fprintf( stderr
, " header_size=%u", req
->header_size
);
4533 fprintf( stderr
, ", read_data=%d", req
->read_data
);
4536 static void dump_get_rawinput_buffer_reply( const struct get_rawinput_buffer_reply
*req
)
4538 fprintf( stderr
, " next_size=%u", req
->next_size
);
4539 fprintf( stderr
, ", time=%08x", req
->time
);
4540 fprintf( stderr
, ", count=%08x", req
->count
);
4541 dump_varargs_bytes( ", data=", cur_size
);
4544 static void dump_update_rawinput_devices_request( const struct update_rawinput_devices_request
*req
)
4546 dump_varargs_rawinput_devices( " devices=", cur_size
);
4549 static void dump_create_job_request( const struct create_job_request
*req
)
4551 fprintf( stderr
, " access=%08x", req
->access
);
4552 dump_varargs_object_attributes( ", objattr=", cur_size
);
4555 static void dump_create_job_reply( const struct create_job_reply
*req
)
4557 fprintf( stderr
, " handle=%04x", req
->handle
);
4560 static void dump_open_job_request( const struct open_job_request
*req
)
4562 fprintf( stderr
, " access=%08x", req
->access
);
4563 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
4564 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
4565 dump_varargs_unicode_str( ", name=", cur_size
);
4568 static void dump_open_job_reply( const struct open_job_reply
*req
)
4570 fprintf( stderr
, " handle=%04x", req
->handle
);
4573 static void dump_assign_job_request( const struct assign_job_request
*req
)
4575 fprintf( stderr
, " job=%04x", req
->job
);
4576 fprintf( stderr
, ", process=%04x", req
->process
);
4579 static void dump_process_in_job_request( const struct process_in_job_request
*req
)
4581 fprintf( stderr
, " job=%04x", req
->job
);
4582 fprintf( stderr
, ", process=%04x", req
->process
);
4585 static void dump_set_job_limits_request( const struct set_job_limits_request
*req
)
4587 fprintf( stderr
, " handle=%04x", req
->handle
);
4588 fprintf( stderr
, ", limit_flags=%08x", req
->limit_flags
);
4591 static void dump_set_job_completion_port_request( const struct set_job_completion_port_request
*req
)
4593 fprintf( stderr
, " job=%04x", req
->job
);
4594 fprintf( stderr
, ", port=%04x", req
->port
);
4595 dump_uint64( ", key=", &req
->key
);
4598 static void dump_get_job_info_request( const struct get_job_info_request
*req
)
4600 fprintf( stderr
, " handle=%04x", req
->handle
);
4603 static void dump_get_job_info_reply( const struct get_job_info_reply
*req
)
4605 fprintf( stderr
, " total_processes=%d", req
->total_processes
);
4606 fprintf( stderr
, ", active_processes=%d", req
->active_processes
);
4607 dump_varargs_uints( ", pids=", cur_size
);
4610 static void dump_terminate_job_request( const struct terminate_job_request
*req
)
4612 fprintf( stderr
, " handle=%04x", req
->handle
);
4613 fprintf( stderr
, ", status=%d", req
->status
);
4616 static void dump_suspend_process_request( const struct suspend_process_request
*req
)
4618 fprintf( stderr
, " handle=%04x", req
->handle
);
4621 static void dump_resume_process_request( const struct resume_process_request
*req
)
4623 fprintf( stderr
, " handle=%04x", req
->handle
);
4626 static void dump_get_next_thread_request( const struct get_next_thread_request
*req
)
4628 fprintf( stderr
, " process=%04x", req
->process
);
4629 fprintf( stderr
, ", last=%04x", req
->last
);
4630 fprintf( stderr
, ", access=%08x", req
->access
);
4631 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
4632 fprintf( stderr
, ", flags=%08x", req
->flags
);
4635 static void dump_get_next_thread_reply( const struct get_next_thread_reply
*req
)
4637 fprintf( stderr
, " handle=%04x", req
->handle
);
4640 static void dump_set_keyboard_repeat_request( const struct set_keyboard_repeat_request
*req
)
4642 fprintf( stderr
, " enable=%d", req
->enable
);
4643 fprintf( stderr
, ", delay=%d", req
->delay
);
4644 fprintf( stderr
, ", period=%d", req
->period
);
4647 static void dump_set_keyboard_repeat_reply( const struct set_keyboard_repeat_reply
*req
)
4649 fprintf( stderr
, " enable=%d", req
->enable
);
4652 static const dump_func req_dumpers
[REQ_NB_REQUESTS
] = {
4653 (dump_func
)dump_new_process_request
,
4654 (dump_func
)dump_get_new_process_info_request
,
4655 (dump_func
)dump_new_thread_request
,
4656 (dump_func
)dump_get_startup_info_request
,
4657 (dump_func
)dump_init_process_done_request
,
4658 (dump_func
)dump_init_first_thread_request
,
4659 (dump_func
)dump_init_thread_request
,
4660 (dump_func
)dump_terminate_process_request
,
4661 (dump_func
)dump_terminate_thread_request
,
4662 (dump_func
)dump_get_process_info_request
,
4663 (dump_func
)dump_get_process_debug_info_request
,
4664 (dump_func
)dump_get_process_image_name_request
,
4665 (dump_func
)dump_get_process_vm_counters_request
,
4666 (dump_func
)dump_set_process_info_request
,
4667 (dump_func
)dump_get_thread_info_request
,
4668 (dump_func
)dump_get_thread_times_request
,
4669 (dump_func
)dump_set_thread_info_request
,
4670 (dump_func
)dump_suspend_thread_request
,
4671 (dump_func
)dump_resume_thread_request
,
4672 (dump_func
)dump_queue_apc_request
,
4673 (dump_func
)dump_get_apc_result_request
,
4674 (dump_func
)dump_close_handle_request
,
4675 (dump_func
)dump_set_handle_info_request
,
4676 (dump_func
)dump_dup_handle_request
,
4677 (dump_func
)dump_compare_objects_request
,
4678 (dump_func
)dump_set_object_permanence_request
,
4679 (dump_func
)dump_open_process_request
,
4680 (dump_func
)dump_open_thread_request
,
4681 (dump_func
)dump_select_request
,
4682 (dump_func
)dump_create_event_request
,
4683 (dump_func
)dump_event_op_request
,
4684 (dump_func
)dump_query_event_request
,
4685 (dump_func
)dump_open_event_request
,
4686 (dump_func
)dump_create_keyed_event_request
,
4687 (dump_func
)dump_open_keyed_event_request
,
4688 (dump_func
)dump_create_mutex_request
,
4689 (dump_func
)dump_release_mutex_request
,
4690 (dump_func
)dump_open_mutex_request
,
4691 (dump_func
)dump_query_mutex_request
,
4692 (dump_func
)dump_create_semaphore_request
,
4693 (dump_func
)dump_release_semaphore_request
,
4694 (dump_func
)dump_query_semaphore_request
,
4695 (dump_func
)dump_open_semaphore_request
,
4696 (dump_func
)dump_create_file_request
,
4697 (dump_func
)dump_open_file_object_request
,
4698 (dump_func
)dump_alloc_file_handle_request
,
4699 (dump_func
)dump_get_handle_unix_name_request
,
4700 (dump_func
)dump_get_handle_fd_request
,
4701 (dump_func
)dump_get_directory_cache_entry_request
,
4702 (dump_func
)dump_flush_request
,
4703 (dump_func
)dump_get_file_info_request
,
4704 (dump_func
)dump_get_volume_info_request
,
4705 (dump_func
)dump_lock_file_request
,
4706 (dump_func
)dump_unlock_file_request
,
4707 (dump_func
)dump_recv_socket_request
,
4708 (dump_func
)dump_send_socket_request
,
4709 (dump_func
)dump_socket_get_events_request
,
4710 (dump_func
)dump_socket_send_icmp_id_request
,
4711 (dump_func
)dump_socket_get_icmp_id_request
,
4712 (dump_func
)dump_get_next_console_request_request
,
4713 (dump_func
)dump_read_directory_changes_request
,
4714 (dump_func
)dump_read_change_request
,
4715 (dump_func
)dump_create_mapping_request
,
4716 (dump_func
)dump_open_mapping_request
,
4717 (dump_func
)dump_get_mapping_info_request
,
4718 (dump_func
)dump_get_image_map_address_request
,
4719 (dump_func
)dump_map_view_request
,
4720 (dump_func
)dump_map_image_view_request
,
4721 (dump_func
)dump_map_builtin_view_request
,
4722 (dump_func
)dump_get_image_view_info_request
,
4723 (dump_func
)dump_unmap_view_request
,
4724 (dump_func
)dump_get_mapping_committed_range_request
,
4725 (dump_func
)dump_add_mapping_committed_range_request
,
4726 (dump_func
)dump_is_same_mapping_request
,
4727 (dump_func
)dump_get_mapping_filename_request
,
4728 (dump_func
)dump_list_processes_request
,
4729 (dump_func
)dump_create_debug_obj_request
,
4730 (dump_func
)dump_wait_debug_event_request
,
4731 (dump_func
)dump_queue_exception_event_request
,
4732 (dump_func
)dump_get_exception_status_request
,
4733 (dump_func
)dump_continue_debug_event_request
,
4734 (dump_func
)dump_debug_process_request
,
4735 (dump_func
)dump_set_debug_obj_info_request
,
4736 (dump_func
)dump_read_process_memory_request
,
4737 (dump_func
)dump_write_process_memory_request
,
4738 (dump_func
)dump_create_key_request
,
4739 (dump_func
)dump_open_key_request
,
4740 (dump_func
)dump_delete_key_request
,
4741 (dump_func
)dump_flush_key_request
,
4742 (dump_func
)dump_enum_key_request
,
4743 (dump_func
)dump_set_key_value_request
,
4744 (dump_func
)dump_get_key_value_request
,
4745 (dump_func
)dump_enum_key_value_request
,
4746 (dump_func
)dump_delete_key_value_request
,
4747 (dump_func
)dump_load_registry_request
,
4748 (dump_func
)dump_unload_registry_request
,
4749 (dump_func
)dump_save_registry_request
,
4750 (dump_func
)dump_set_registry_notification_request
,
4751 (dump_func
)dump_rename_key_request
,
4752 (dump_func
)dump_create_timer_request
,
4753 (dump_func
)dump_open_timer_request
,
4754 (dump_func
)dump_set_timer_request
,
4755 (dump_func
)dump_cancel_timer_request
,
4756 (dump_func
)dump_get_timer_info_request
,
4757 (dump_func
)dump_get_thread_context_request
,
4758 (dump_func
)dump_set_thread_context_request
,
4759 (dump_func
)dump_get_selector_entry_request
,
4760 (dump_func
)dump_add_atom_request
,
4761 (dump_func
)dump_delete_atom_request
,
4762 (dump_func
)dump_find_atom_request
,
4763 (dump_func
)dump_get_atom_information_request
,
4764 (dump_func
)dump_get_msg_queue_request
,
4765 (dump_func
)dump_set_queue_fd_request
,
4766 (dump_func
)dump_set_queue_mask_request
,
4767 (dump_func
)dump_get_queue_status_request
,
4768 (dump_func
)dump_get_process_idle_event_request
,
4769 (dump_func
)dump_send_message_request
,
4770 (dump_func
)dump_post_quit_message_request
,
4771 (dump_func
)dump_send_hardware_message_request
,
4772 (dump_func
)dump_get_message_request
,
4773 (dump_func
)dump_reply_message_request
,
4774 (dump_func
)dump_accept_hardware_message_request
,
4775 (dump_func
)dump_get_message_reply_request
,
4776 (dump_func
)dump_set_win_timer_request
,
4777 (dump_func
)dump_kill_win_timer_request
,
4778 (dump_func
)dump_is_window_hung_request
,
4779 (dump_func
)dump_get_serial_info_request
,
4780 (dump_func
)dump_set_serial_info_request
,
4781 (dump_func
)dump_cancel_sync_request
,
4782 (dump_func
)dump_register_async_request
,
4783 (dump_func
)dump_cancel_async_request
,
4784 (dump_func
)dump_get_async_result_request
,
4785 (dump_func
)dump_set_async_direct_result_request
,
4786 (dump_func
)dump_read_request
,
4787 (dump_func
)dump_write_request
,
4788 (dump_func
)dump_ioctl_request
,
4789 (dump_func
)dump_set_irp_result_request
,
4790 (dump_func
)dump_create_named_pipe_request
,
4791 (dump_func
)dump_set_named_pipe_info_request
,
4792 (dump_func
)dump_create_window_request
,
4793 (dump_func
)dump_destroy_window_request
,
4794 (dump_func
)dump_get_desktop_window_request
,
4795 (dump_func
)dump_set_window_owner_request
,
4796 (dump_func
)dump_get_window_info_request
,
4797 (dump_func
)dump_set_window_info_request
,
4798 (dump_func
)dump_set_parent_request
,
4799 (dump_func
)dump_get_window_parents_request
,
4800 (dump_func
)dump_get_window_children_request
,
4801 (dump_func
)dump_get_window_children_from_point_request
,
4802 (dump_func
)dump_get_window_tree_request
,
4803 (dump_func
)dump_set_window_pos_request
,
4804 (dump_func
)dump_get_window_rectangles_request
,
4805 (dump_func
)dump_get_window_text_request
,
4806 (dump_func
)dump_set_window_text_request
,
4807 (dump_func
)dump_get_windows_offset_request
,
4808 (dump_func
)dump_get_visible_region_request
,
4809 (dump_func
)dump_get_window_region_request
,
4810 (dump_func
)dump_set_window_region_request
,
4811 (dump_func
)dump_get_update_region_request
,
4812 (dump_func
)dump_update_window_zorder_request
,
4813 (dump_func
)dump_redraw_window_request
,
4814 (dump_func
)dump_set_window_property_request
,
4815 (dump_func
)dump_remove_window_property_request
,
4816 (dump_func
)dump_get_window_property_request
,
4817 (dump_func
)dump_get_window_properties_request
,
4818 (dump_func
)dump_create_winstation_request
,
4819 (dump_func
)dump_open_winstation_request
,
4820 (dump_func
)dump_close_winstation_request
,
4821 (dump_func
)dump_get_process_winstation_request
,
4822 (dump_func
)dump_set_process_winstation_request
,
4823 (dump_func
)dump_enum_winstation_request
,
4824 (dump_func
)dump_create_desktop_request
,
4825 (dump_func
)dump_open_desktop_request
,
4826 (dump_func
)dump_open_input_desktop_request
,
4827 (dump_func
)dump_set_input_desktop_request
,
4828 (dump_func
)dump_close_desktop_request
,
4829 (dump_func
)dump_get_thread_desktop_request
,
4830 (dump_func
)dump_set_thread_desktop_request
,
4831 (dump_func
)dump_enum_desktop_request
,
4832 (dump_func
)dump_set_user_object_info_request
,
4833 (dump_func
)dump_register_hotkey_request
,
4834 (dump_func
)dump_unregister_hotkey_request
,
4835 (dump_func
)dump_attach_thread_input_request
,
4836 (dump_func
)dump_get_thread_input_request
,
4837 (dump_func
)dump_get_last_input_time_request
,
4838 (dump_func
)dump_get_key_state_request
,
4839 (dump_func
)dump_set_key_state_request
,
4840 (dump_func
)dump_set_foreground_window_request
,
4841 (dump_func
)dump_set_focus_window_request
,
4842 (dump_func
)dump_set_active_window_request
,
4843 (dump_func
)dump_set_capture_window_request
,
4844 (dump_func
)dump_set_caret_window_request
,
4845 (dump_func
)dump_set_caret_info_request
,
4846 (dump_func
)dump_set_hook_request
,
4847 (dump_func
)dump_remove_hook_request
,
4848 (dump_func
)dump_start_hook_chain_request
,
4849 (dump_func
)dump_finish_hook_chain_request
,
4850 (dump_func
)dump_get_hook_info_request
,
4851 (dump_func
)dump_create_class_request
,
4852 (dump_func
)dump_destroy_class_request
,
4853 (dump_func
)dump_set_class_info_request
,
4854 (dump_func
)dump_open_clipboard_request
,
4855 (dump_func
)dump_close_clipboard_request
,
4856 (dump_func
)dump_empty_clipboard_request
,
4857 (dump_func
)dump_set_clipboard_data_request
,
4858 (dump_func
)dump_get_clipboard_data_request
,
4859 (dump_func
)dump_get_clipboard_formats_request
,
4860 (dump_func
)dump_enum_clipboard_formats_request
,
4861 (dump_func
)dump_release_clipboard_request
,
4862 (dump_func
)dump_get_clipboard_info_request
,
4863 (dump_func
)dump_set_clipboard_viewer_request
,
4864 (dump_func
)dump_add_clipboard_listener_request
,
4865 (dump_func
)dump_remove_clipboard_listener_request
,
4866 (dump_func
)dump_create_token_request
,
4867 (dump_func
)dump_open_token_request
,
4868 (dump_func
)dump_set_global_windows_request
,
4869 (dump_func
)dump_adjust_token_privileges_request
,
4870 (dump_func
)dump_get_token_privileges_request
,
4871 (dump_func
)dump_check_token_privileges_request
,
4872 (dump_func
)dump_duplicate_token_request
,
4873 (dump_func
)dump_filter_token_request
,
4874 (dump_func
)dump_access_check_request
,
4875 (dump_func
)dump_get_token_sid_request
,
4876 (dump_func
)dump_get_token_groups_request
,
4877 (dump_func
)dump_get_token_default_dacl_request
,
4878 (dump_func
)dump_set_token_default_dacl_request
,
4879 (dump_func
)dump_set_security_object_request
,
4880 (dump_func
)dump_get_security_object_request
,
4881 (dump_func
)dump_get_system_handles_request
,
4882 (dump_func
)dump_create_mailslot_request
,
4883 (dump_func
)dump_set_mailslot_info_request
,
4884 (dump_func
)dump_create_directory_request
,
4885 (dump_func
)dump_open_directory_request
,
4886 (dump_func
)dump_get_directory_entries_request
,
4887 (dump_func
)dump_create_symlink_request
,
4888 (dump_func
)dump_open_symlink_request
,
4889 (dump_func
)dump_query_symlink_request
,
4890 (dump_func
)dump_get_object_info_request
,
4891 (dump_func
)dump_get_object_name_request
,
4892 (dump_func
)dump_get_object_type_request
,
4893 (dump_func
)dump_get_object_types_request
,
4894 (dump_func
)dump_allocate_locally_unique_id_request
,
4895 (dump_func
)dump_create_device_manager_request
,
4896 (dump_func
)dump_create_device_request
,
4897 (dump_func
)dump_delete_device_request
,
4898 (dump_func
)dump_get_next_device_request_request
,
4899 (dump_func
)dump_get_kernel_object_ptr_request
,
4900 (dump_func
)dump_set_kernel_object_ptr_request
,
4901 (dump_func
)dump_grab_kernel_object_request
,
4902 (dump_func
)dump_release_kernel_object_request
,
4903 (dump_func
)dump_get_kernel_object_handle_request
,
4904 (dump_func
)dump_make_process_system_request
,
4905 (dump_func
)dump_get_token_info_request
,
4906 (dump_func
)dump_create_linked_token_request
,
4907 (dump_func
)dump_create_completion_request
,
4908 (dump_func
)dump_open_completion_request
,
4909 (dump_func
)dump_add_completion_request
,
4910 (dump_func
)dump_remove_completion_request
,
4911 (dump_func
)dump_query_completion_request
,
4912 (dump_func
)dump_set_completion_info_request
,
4913 (dump_func
)dump_add_fd_completion_request
,
4914 (dump_func
)dump_set_fd_completion_mode_request
,
4915 (dump_func
)dump_set_fd_disp_info_request
,
4916 (dump_func
)dump_set_fd_name_info_request
,
4917 (dump_func
)dump_set_fd_eof_info_request
,
4918 (dump_func
)dump_get_window_layered_info_request
,
4919 (dump_func
)dump_set_window_layered_info_request
,
4920 (dump_func
)dump_alloc_user_handle_request
,
4921 (dump_func
)dump_free_user_handle_request
,
4922 (dump_func
)dump_set_cursor_request
,
4923 (dump_func
)dump_get_cursor_history_request
,
4924 (dump_func
)dump_get_rawinput_buffer_request
,
4925 (dump_func
)dump_update_rawinput_devices_request
,
4926 (dump_func
)dump_create_job_request
,
4927 (dump_func
)dump_open_job_request
,
4928 (dump_func
)dump_assign_job_request
,
4929 (dump_func
)dump_process_in_job_request
,
4930 (dump_func
)dump_set_job_limits_request
,
4931 (dump_func
)dump_set_job_completion_port_request
,
4932 (dump_func
)dump_get_job_info_request
,
4933 (dump_func
)dump_terminate_job_request
,
4934 (dump_func
)dump_suspend_process_request
,
4935 (dump_func
)dump_resume_process_request
,
4936 (dump_func
)dump_get_next_thread_request
,
4937 (dump_func
)dump_set_keyboard_repeat_request
,
4940 static const dump_func reply_dumpers
[REQ_NB_REQUESTS
] = {
4941 (dump_func
)dump_new_process_reply
,
4942 (dump_func
)dump_get_new_process_info_reply
,
4943 (dump_func
)dump_new_thread_reply
,
4944 (dump_func
)dump_get_startup_info_reply
,
4945 (dump_func
)dump_init_process_done_reply
,
4946 (dump_func
)dump_init_first_thread_reply
,
4947 (dump_func
)dump_init_thread_reply
,
4948 (dump_func
)dump_terminate_process_reply
,
4949 (dump_func
)dump_terminate_thread_reply
,
4950 (dump_func
)dump_get_process_info_reply
,
4951 (dump_func
)dump_get_process_debug_info_reply
,
4952 (dump_func
)dump_get_process_image_name_reply
,
4953 (dump_func
)dump_get_process_vm_counters_reply
,
4955 (dump_func
)dump_get_thread_info_reply
,
4956 (dump_func
)dump_get_thread_times_reply
,
4958 (dump_func
)dump_suspend_thread_reply
,
4959 (dump_func
)dump_resume_thread_reply
,
4960 (dump_func
)dump_queue_apc_reply
,
4961 (dump_func
)dump_get_apc_result_reply
,
4963 (dump_func
)dump_set_handle_info_reply
,
4964 (dump_func
)dump_dup_handle_reply
,
4967 (dump_func
)dump_open_process_reply
,
4968 (dump_func
)dump_open_thread_reply
,
4969 (dump_func
)dump_select_reply
,
4970 (dump_func
)dump_create_event_reply
,
4971 (dump_func
)dump_event_op_reply
,
4972 (dump_func
)dump_query_event_reply
,
4973 (dump_func
)dump_open_event_reply
,
4974 (dump_func
)dump_create_keyed_event_reply
,
4975 (dump_func
)dump_open_keyed_event_reply
,
4976 (dump_func
)dump_create_mutex_reply
,
4977 (dump_func
)dump_release_mutex_reply
,
4978 (dump_func
)dump_open_mutex_reply
,
4979 (dump_func
)dump_query_mutex_reply
,
4980 (dump_func
)dump_create_semaphore_reply
,
4981 (dump_func
)dump_release_semaphore_reply
,
4982 (dump_func
)dump_query_semaphore_reply
,
4983 (dump_func
)dump_open_semaphore_reply
,
4984 (dump_func
)dump_create_file_reply
,
4985 (dump_func
)dump_open_file_object_reply
,
4986 (dump_func
)dump_alloc_file_handle_reply
,
4987 (dump_func
)dump_get_handle_unix_name_reply
,
4988 (dump_func
)dump_get_handle_fd_reply
,
4989 (dump_func
)dump_get_directory_cache_entry_reply
,
4990 (dump_func
)dump_flush_reply
,
4991 (dump_func
)dump_get_file_info_reply
,
4992 (dump_func
)dump_get_volume_info_reply
,
4993 (dump_func
)dump_lock_file_reply
,
4995 (dump_func
)dump_recv_socket_reply
,
4996 (dump_func
)dump_send_socket_reply
,
4997 (dump_func
)dump_socket_get_events_reply
,
4999 (dump_func
)dump_socket_get_icmp_id_reply
,
5000 (dump_func
)dump_get_next_console_request_reply
,
5002 (dump_func
)dump_read_change_reply
,
5003 (dump_func
)dump_create_mapping_reply
,
5004 (dump_func
)dump_open_mapping_reply
,
5005 (dump_func
)dump_get_mapping_info_reply
,
5006 (dump_func
)dump_get_image_map_address_reply
,
5010 (dump_func
)dump_get_image_view_info_reply
,
5012 (dump_func
)dump_get_mapping_committed_range_reply
,
5015 (dump_func
)dump_get_mapping_filename_reply
,
5016 (dump_func
)dump_list_processes_reply
,
5017 (dump_func
)dump_create_debug_obj_reply
,
5018 (dump_func
)dump_wait_debug_event_reply
,
5019 (dump_func
)dump_queue_exception_event_reply
,
5024 (dump_func
)dump_read_process_memory_reply
,
5026 (dump_func
)dump_create_key_reply
,
5027 (dump_func
)dump_open_key_reply
,
5030 (dump_func
)dump_enum_key_reply
,
5032 (dump_func
)dump_get_key_value_reply
,
5033 (dump_func
)dump_enum_key_value_reply
,
5040 (dump_func
)dump_create_timer_reply
,
5041 (dump_func
)dump_open_timer_reply
,
5042 (dump_func
)dump_set_timer_reply
,
5043 (dump_func
)dump_cancel_timer_reply
,
5044 (dump_func
)dump_get_timer_info_reply
,
5045 (dump_func
)dump_get_thread_context_reply
,
5046 (dump_func
)dump_set_thread_context_reply
,
5047 (dump_func
)dump_get_selector_entry_reply
,
5048 (dump_func
)dump_add_atom_reply
,
5050 (dump_func
)dump_find_atom_reply
,
5051 (dump_func
)dump_get_atom_information_reply
,
5052 (dump_func
)dump_get_msg_queue_reply
,
5054 (dump_func
)dump_set_queue_mask_reply
,
5055 (dump_func
)dump_get_queue_status_reply
,
5056 (dump_func
)dump_get_process_idle_event_reply
,
5059 (dump_func
)dump_send_hardware_message_reply
,
5060 (dump_func
)dump_get_message_reply
,
5063 (dump_func
)dump_get_message_reply_reply
,
5064 (dump_func
)dump_set_win_timer_reply
,
5066 (dump_func
)dump_is_window_hung_reply
,
5067 (dump_func
)dump_get_serial_info_reply
,
5072 (dump_func
)dump_get_async_result_reply
,
5073 (dump_func
)dump_set_async_direct_result_reply
,
5074 (dump_func
)dump_read_reply
,
5075 (dump_func
)dump_write_reply
,
5076 (dump_func
)dump_ioctl_reply
,
5078 (dump_func
)dump_create_named_pipe_reply
,
5080 (dump_func
)dump_create_window_reply
,
5082 (dump_func
)dump_get_desktop_window_reply
,
5083 (dump_func
)dump_set_window_owner_reply
,
5084 (dump_func
)dump_get_window_info_reply
,
5085 (dump_func
)dump_set_window_info_reply
,
5086 (dump_func
)dump_set_parent_reply
,
5087 (dump_func
)dump_get_window_parents_reply
,
5088 (dump_func
)dump_get_window_children_reply
,
5089 (dump_func
)dump_get_window_children_from_point_reply
,
5090 (dump_func
)dump_get_window_tree_reply
,
5091 (dump_func
)dump_set_window_pos_reply
,
5092 (dump_func
)dump_get_window_rectangles_reply
,
5093 (dump_func
)dump_get_window_text_reply
,
5095 (dump_func
)dump_get_windows_offset_reply
,
5096 (dump_func
)dump_get_visible_region_reply
,
5097 (dump_func
)dump_get_window_region_reply
,
5099 (dump_func
)dump_get_update_region_reply
,
5103 (dump_func
)dump_remove_window_property_reply
,
5104 (dump_func
)dump_get_window_property_reply
,
5105 (dump_func
)dump_get_window_properties_reply
,
5106 (dump_func
)dump_create_winstation_reply
,
5107 (dump_func
)dump_open_winstation_reply
,
5109 (dump_func
)dump_get_process_winstation_reply
,
5111 (dump_func
)dump_enum_winstation_reply
,
5112 (dump_func
)dump_create_desktop_reply
,
5113 (dump_func
)dump_open_desktop_reply
,
5114 (dump_func
)dump_open_input_desktop_reply
,
5117 (dump_func
)dump_get_thread_desktop_reply
,
5118 (dump_func
)dump_set_thread_desktop_reply
,
5119 (dump_func
)dump_enum_desktop_reply
,
5120 (dump_func
)dump_set_user_object_info_reply
,
5121 (dump_func
)dump_register_hotkey_reply
,
5122 (dump_func
)dump_unregister_hotkey_reply
,
5124 (dump_func
)dump_get_thread_input_reply
,
5125 (dump_func
)dump_get_last_input_time_reply
,
5126 (dump_func
)dump_get_key_state_reply
,
5128 (dump_func
)dump_set_foreground_window_reply
,
5129 (dump_func
)dump_set_focus_window_reply
,
5130 (dump_func
)dump_set_active_window_reply
,
5131 (dump_func
)dump_set_capture_window_reply
,
5132 (dump_func
)dump_set_caret_window_reply
,
5133 (dump_func
)dump_set_caret_info_reply
,
5134 (dump_func
)dump_set_hook_reply
,
5135 (dump_func
)dump_remove_hook_reply
,
5136 (dump_func
)dump_start_hook_chain_reply
,
5138 (dump_func
)dump_get_hook_info_reply
,
5139 (dump_func
)dump_create_class_reply
,
5140 (dump_func
)dump_destroy_class_reply
,
5141 (dump_func
)dump_set_class_info_reply
,
5142 (dump_func
)dump_open_clipboard_reply
,
5143 (dump_func
)dump_close_clipboard_reply
,
5145 (dump_func
)dump_set_clipboard_data_reply
,
5146 (dump_func
)dump_get_clipboard_data_reply
,
5147 (dump_func
)dump_get_clipboard_formats_reply
,
5148 (dump_func
)dump_enum_clipboard_formats_reply
,
5149 (dump_func
)dump_release_clipboard_reply
,
5150 (dump_func
)dump_get_clipboard_info_reply
,
5151 (dump_func
)dump_set_clipboard_viewer_reply
,
5154 (dump_func
)dump_create_token_reply
,
5155 (dump_func
)dump_open_token_reply
,
5156 (dump_func
)dump_set_global_windows_reply
,
5157 (dump_func
)dump_adjust_token_privileges_reply
,
5158 (dump_func
)dump_get_token_privileges_reply
,
5159 (dump_func
)dump_check_token_privileges_reply
,
5160 (dump_func
)dump_duplicate_token_reply
,
5161 (dump_func
)dump_filter_token_reply
,
5162 (dump_func
)dump_access_check_reply
,
5163 (dump_func
)dump_get_token_sid_reply
,
5164 (dump_func
)dump_get_token_groups_reply
,
5165 (dump_func
)dump_get_token_default_dacl_reply
,
5168 (dump_func
)dump_get_security_object_reply
,
5169 (dump_func
)dump_get_system_handles_reply
,
5170 (dump_func
)dump_create_mailslot_reply
,
5171 (dump_func
)dump_set_mailslot_info_reply
,
5172 (dump_func
)dump_create_directory_reply
,
5173 (dump_func
)dump_open_directory_reply
,
5174 (dump_func
)dump_get_directory_entries_reply
,
5175 (dump_func
)dump_create_symlink_reply
,
5176 (dump_func
)dump_open_symlink_reply
,
5177 (dump_func
)dump_query_symlink_reply
,
5178 (dump_func
)dump_get_object_info_reply
,
5179 (dump_func
)dump_get_object_name_reply
,
5180 (dump_func
)dump_get_object_type_reply
,
5181 (dump_func
)dump_get_object_types_reply
,
5182 (dump_func
)dump_allocate_locally_unique_id_reply
,
5183 (dump_func
)dump_create_device_manager_reply
,
5186 (dump_func
)dump_get_next_device_request_reply
,
5187 (dump_func
)dump_get_kernel_object_ptr_reply
,
5191 (dump_func
)dump_get_kernel_object_handle_reply
,
5192 (dump_func
)dump_make_process_system_reply
,
5193 (dump_func
)dump_get_token_info_reply
,
5194 (dump_func
)dump_create_linked_token_reply
,
5195 (dump_func
)dump_create_completion_reply
,
5196 (dump_func
)dump_open_completion_reply
,
5198 (dump_func
)dump_remove_completion_reply
,
5199 (dump_func
)dump_query_completion_reply
,
5206 (dump_func
)dump_get_window_layered_info_reply
,
5208 (dump_func
)dump_alloc_user_handle_reply
,
5210 (dump_func
)dump_set_cursor_reply
,
5211 (dump_func
)dump_get_cursor_history_reply
,
5212 (dump_func
)dump_get_rawinput_buffer_reply
,
5214 (dump_func
)dump_create_job_reply
,
5215 (dump_func
)dump_open_job_reply
,
5220 (dump_func
)dump_get_job_info_reply
,
5224 (dump_func
)dump_get_next_thread_reply
,
5225 (dump_func
)dump_set_keyboard_repeat_reply
,
5228 static const char * const req_names
[REQ_NB_REQUESTS
] = {
5230 "get_new_process_info",
5233 "init_process_done",
5234 "init_first_thread",
5236 "terminate_process",
5239 "get_process_debug_info",
5240 "get_process_image_name",
5241 "get_process_vm_counters",
5254 "set_object_permanence",
5262 "create_keyed_event",
5269 "release_semaphore",
5274 "alloc_file_handle",
5275 "get_handle_unix_name",
5277 "get_directory_cache_entry",
5285 "socket_get_events",
5286 "socket_send_icmp_id",
5287 "socket_get_icmp_id",
5288 "get_next_console_request",
5289 "read_directory_changes",
5294 "get_image_map_address",
5298 "get_image_view_info",
5300 "get_mapping_committed_range",
5301 "add_mapping_committed_range",
5303 "get_mapping_filename",
5307 "queue_exception_event",
5308 "get_exception_status",
5309 "continue_debug_event",
5311 "set_debug_obj_info",
5312 "read_process_memory",
5313 "write_process_memory",
5326 "set_registry_notification",
5333 "get_thread_context",
5334 "set_thread_context",
5335 "get_selector_entry",
5339 "get_atom_information",
5344 "get_process_idle_event",
5346 "post_quit_message",
5347 "send_hardware_message",
5350 "accept_hardware_message",
5351 "get_message_reply",
5361 "set_async_direct_result",
5366 "create_named_pipe",
5367 "set_named_pipe_info",
5370 "get_desktop_window",
5375 "get_window_parents",
5376 "get_window_children",
5377 "get_window_children_from_point",
5380 "get_window_rectangles",
5383 "get_windows_offset",
5384 "get_visible_region",
5385 "get_window_region",
5386 "set_window_region",
5387 "get_update_region",
5388 "update_window_zorder",
5390 "set_window_property",
5391 "remove_window_property",
5392 "get_window_property",
5393 "get_window_properties",
5394 "create_winstation",
5397 "get_process_winstation",
5398 "set_process_winstation",
5402 "open_input_desktop",
5403 "set_input_desktop",
5405 "get_thread_desktop",
5406 "set_thread_desktop",
5408 "set_user_object_info",
5410 "unregister_hotkey",
5411 "attach_thread_input",
5413 "get_last_input_time",
5416 "set_foreground_window",
5418 "set_active_window",
5419 "set_capture_window",
5425 "finish_hook_chain",
5433 "set_clipboard_data",
5434 "get_clipboard_data",
5435 "get_clipboard_formats",
5436 "enum_clipboard_formats",
5437 "release_clipboard",
5438 "get_clipboard_info",
5439 "set_clipboard_viewer",
5440 "add_clipboard_listener",
5441 "remove_clipboard_listener",
5444 "set_global_windows",
5445 "adjust_token_privileges",
5446 "get_token_privileges",
5447 "check_token_privileges",
5453 "get_token_default_dacl",
5454 "set_token_default_dacl",
5455 "set_security_object",
5456 "get_security_object",
5457 "get_system_handles",
5459 "set_mailslot_info",
5462 "get_directory_entries",
5470 "allocate_locally_unique_id",
5471 "create_device_manager",
5474 "get_next_device_request",
5475 "get_kernel_object_ptr",
5476 "set_kernel_object_ptr",
5477 "grab_kernel_object",
5478 "release_kernel_object",
5479 "get_kernel_object_handle",
5480 "make_process_system",
5482 "create_linked_token",
5483 "create_completion",
5486 "remove_completion",
5488 "set_completion_info",
5489 "add_fd_completion",
5490 "set_fd_completion_mode",
5494 "get_window_layered_info",
5495 "set_window_layered_info",
5496 "alloc_user_handle",
5499 "get_cursor_history",
5500 "get_rawinput_buffer",
5501 "update_rawinput_devices",
5507 "set_job_completion_port",
5513 "set_keyboard_repeat",
5522 { "ABANDONED_WAIT_0", STATUS_ABANDONED_WAIT_0
},
5523 { "ACCESS_DENIED", STATUS_ACCESS_DENIED
},
5524 { "ACCESS_VIOLATION", STATUS_ACCESS_VIOLATION
},
5525 { "ADDRESS_ALREADY_ASSOCIATED", STATUS_ADDRESS_ALREADY_ASSOCIATED
},
5526 { "ALERTED", STATUS_ALERTED
},
5527 { "BAD_DEVICE_TYPE", STATUS_BAD_DEVICE_TYPE
},
5528 { "BAD_IMPERSONATION_LEVEL", STATUS_BAD_IMPERSONATION_LEVEL
},
5529 { "BUFFER_OVERFLOW", STATUS_BUFFER_OVERFLOW
},
5530 { "BUFFER_TOO_SMALL", STATUS_BUFFER_TOO_SMALL
},
5531 { "CANCELLED", STATUS_CANCELLED
},
5532 { "CANNOT_DELETE", STATUS_CANNOT_DELETE
},
5533 { "CANT_OPEN_ANONYMOUS", STATUS_CANT_OPEN_ANONYMOUS
},
5534 { "CHILD_MUST_BE_VOLATILE", STATUS_CHILD_MUST_BE_VOLATILE
},
5535 { "CONNECTION_ABORTED", STATUS_CONNECTION_ABORTED
},
5536 { "CONNECTION_ACTIVE", STATUS_CONNECTION_ACTIVE
},
5537 { "CONNECTION_REFUSED", STATUS_CONNECTION_REFUSED
},
5538 { "CONNECTION_RESET", STATUS_CONNECTION_RESET
},
5539 { "DEBUGGER_INACTIVE", STATUS_DEBUGGER_INACTIVE
},
5540 { "DEVICE_BUSY", STATUS_DEVICE_BUSY
},
5541 { "DEVICE_NOT_READY", STATUS_DEVICE_NOT_READY
},
5542 { "DIRECTORY_NOT_EMPTY", STATUS_DIRECTORY_NOT_EMPTY
},
5543 { "DISK_FULL", STATUS_DISK_FULL
},
5544 { "ERROR_CLASS_ALREADY_EXISTS", 0xc0010000 | ERROR_CLASS_ALREADY_EXISTS
},
5545 { "ERROR_CLASS_DOES_NOT_EXIST", 0xc0010000 | ERROR_CLASS_DOES_NOT_EXIST
},
5546 { "ERROR_CLASS_HAS_WINDOWS", 0xc0010000 | ERROR_CLASS_HAS_WINDOWS
},
5547 { "ERROR_CLIPBOARD_NOT_OPEN", 0xc0010000 | ERROR_CLIPBOARD_NOT_OPEN
},
5548 { "ERROR_HOTKEY_ALREADY_REGISTERED", 0xc0010000 | ERROR_HOTKEY_ALREADY_REGISTERED
},
5549 { "ERROR_HOTKEY_NOT_REGISTERED", 0xc0010000 | ERROR_HOTKEY_NOT_REGISTERED
},
5550 { "ERROR_INVALID_CURSOR_HANDLE", 0xc0010000 | ERROR_INVALID_CURSOR_HANDLE
},
5551 { "ERROR_INVALID_INDEX", 0xc0010000 | ERROR_INVALID_INDEX
},
5552 { "ERROR_INVALID_WINDOW_HANDLE", 0xc0010000 | ERROR_INVALID_WINDOW_HANDLE
},
5553 { "ERROR_NO_MORE_USER_HANDLES", 0xc0010000 | ERROR_NO_MORE_USER_HANDLES
},
5554 { "ERROR_WINDOW_OF_OTHER_THREAD", 0xc0010000 | ERROR_WINDOW_OF_OTHER_THREAD
},
5555 { "FILE_DELETED", STATUS_FILE_DELETED
},
5556 { "FILE_INVALID", STATUS_FILE_INVALID
},
5557 { "FILE_IS_A_DIRECTORY", STATUS_FILE_IS_A_DIRECTORY
},
5558 { "FILE_LOCK_CONFLICT", STATUS_FILE_LOCK_CONFLICT
},
5559 { "GENERIC_NOT_MAPPED", STATUS_GENERIC_NOT_MAPPED
},
5560 { "HANDLES_CLOSED", STATUS_HANDLES_CLOSED
},
5561 { "HANDLE_NOT_CLOSABLE", STATUS_HANDLE_NOT_CLOSABLE
},
5562 { "HOST_UNREACHABLE", STATUS_HOST_UNREACHABLE
},
5563 { "ILLEGAL_FUNCTION", STATUS_ILLEGAL_FUNCTION
},
5564 { "IMAGE_MACHINE_TYPE_MISMATCH", STATUS_IMAGE_MACHINE_TYPE_MISMATCH
},
5565 { "IMAGE_NOT_AT_BASE", STATUS_IMAGE_NOT_AT_BASE
},
5566 { "INFO_LENGTH_MISMATCH", STATUS_INFO_LENGTH_MISMATCH
},
5567 { "INSTANCE_NOT_AVAILABLE", STATUS_INSTANCE_NOT_AVAILABLE
},
5568 { "INSUFFICIENT_RESOURCES", STATUS_INSUFFICIENT_RESOURCES
},
5569 { "INVALID_ACL", STATUS_INVALID_ACL
},
5570 { "INVALID_ADDRESS", STATUS_INVALID_ADDRESS
},
5571 { "INVALID_ADDRESS_COMPONENT", STATUS_INVALID_ADDRESS_COMPONENT
},
5572 { "INVALID_CID", STATUS_INVALID_CID
},
5573 { "INVALID_CONNECTION", STATUS_INVALID_CONNECTION
},
5574 { "INVALID_DEVICE_REQUEST", STATUS_INVALID_DEVICE_REQUEST
},
5575 { "INVALID_FILE_FOR_SECTION", STATUS_INVALID_FILE_FOR_SECTION
},
5576 { "INVALID_HANDLE", STATUS_INVALID_HANDLE
},
5577 { "INVALID_IMAGE_FORMAT", STATUS_INVALID_IMAGE_FORMAT
},
5578 { "INVALID_IMAGE_NE_FORMAT", STATUS_INVALID_IMAGE_NE_FORMAT
},
5579 { "INVALID_IMAGE_NOT_MZ", STATUS_INVALID_IMAGE_NOT_MZ
},
5580 { "INVALID_IMAGE_PROTECT", STATUS_INVALID_IMAGE_PROTECT
},
5581 { "INVALID_IMAGE_WIN_16", STATUS_INVALID_IMAGE_WIN_16
},
5582 { "INVALID_IMAGE_WIN_64", STATUS_INVALID_IMAGE_WIN_64
},
5583 { "INVALID_LOCK_SEQUENCE", STATUS_INVALID_LOCK_SEQUENCE
},
5584 { "INVALID_OWNER", STATUS_INVALID_OWNER
},
5585 { "INVALID_PARAMETER", STATUS_INVALID_PARAMETER
},
5586 { "INVALID_PIPE_STATE", STATUS_INVALID_PIPE_STATE
},
5587 { "INVALID_READ_MODE", STATUS_INVALID_READ_MODE
},
5588 { "INVALID_SECURITY_DESCR", STATUS_INVALID_SECURITY_DESCR
},
5589 { "IO_TIMEOUT", STATUS_IO_TIMEOUT
},
5590 { "KERNEL_APC", STATUS_KERNEL_APC
},
5591 { "KEY_DELETED", STATUS_KEY_DELETED
},
5592 { "MAPPED_FILE_SIZE_ZERO", STATUS_MAPPED_FILE_SIZE_ZERO
},
5593 { "MORE_ENTRIES", STATUS_MORE_ENTRIES
},
5594 { "MUTANT_NOT_OWNED", STATUS_MUTANT_NOT_OWNED
},
5595 { "NAME_TOO_LONG", STATUS_NAME_TOO_LONG
},
5596 { "NETWORK_BUSY", STATUS_NETWORK_BUSY
},
5597 { "NETWORK_UNREACHABLE", STATUS_NETWORK_UNREACHABLE
},
5598 { "NOT_ALL_ASSIGNED", STATUS_NOT_ALL_ASSIGNED
},
5599 { "NOT_A_DIRECTORY", STATUS_NOT_A_DIRECTORY
},
5600 { "NOT_FOUND", STATUS_NOT_FOUND
},
5601 { "NOT_IMPLEMENTED", STATUS_NOT_IMPLEMENTED
},
5602 { "NOT_MAPPED_VIEW", STATUS_NOT_MAPPED_VIEW
},
5603 { "NOT_REGISTRY_FILE", STATUS_NOT_REGISTRY_FILE
},
5604 { "NOT_SAME_DEVICE", STATUS_NOT_SAME_DEVICE
},
5605 { "NOT_SAME_OBJECT", STATUS_NOT_SAME_OBJECT
},
5606 { "NOT_SUPPORTED", STATUS_NOT_SUPPORTED
},
5607 { "NO_DATA_DETECTED", STATUS_NO_DATA_DETECTED
},
5608 { "NO_IMPERSONATION_TOKEN", STATUS_NO_IMPERSONATION_TOKEN
},
5609 { "NO_MEMORY", STATUS_NO_MEMORY
},
5610 { "NO_MORE_ENTRIES", STATUS_NO_MORE_ENTRIES
},
5611 { "NO_SUCH_DEVICE", STATUS_NO_SUCH_DEVICE
},
5612 { "NO_SUCH_FILE", STATUS_NO_SUCH_FILE
},
5613 { "NO_TOKEN", STATUS_NO_TOKEN
},
5614 { "OBJECT_NAME_COLLISION", STATUS_OBJECT_NAME_COLLISION
},
5615 { "OBJECT_NAME_EXISTS", STATUS_OBJECT_NAME_EXISTS
},
5616 { "OBJECT_NAME_INVALID", STATUS_OBJECT_NAME_INVALID
},
5617 { "OBJECT_NAME_NOT_FOUND", STATUS_OBJECT_NAME_NOT_FOUND
},
5618 { "OBJECT_PATH_INVALID", STATUS_OBJECT_PATH_INVALID
},
5619 { "OBJECT_PATH_NOT_FOUND", STATUS_OBJECT_PATH_NOT_FOUND
},
5620 { "OBJECT_PATH_SYNTAX_BAD", STATUS_OBJECT_PATH_SYNTAX_BAD
},
5621 { "OBJECT_TYPE_MISMATCH", STATUS_OBJECT_TYPE_MISMATCH
},
5622 { "PENDING", STATUS_PENDING
},
5623 { "PIPE_BROKEN", STATUS_PIPE_BROKEN
},
5624 { "PIPE_BUSY", STATUS_PIPE_BUSY
},
5625 { "PIPE_CLOSING", STATUS_PIPE_CLOSING
},
5626 { "PIPE_CONNECTED", STATUS_PIPE_CONNECTED
},
5627 { "PIPE_DISCONNECTED", STATUS_PIPE_DISCONNECTED
},
5628 { "PIPE_EMPTY", STATUS_PIPE_EMPTY
},
5629 { "PIPE_LISTENING", STATUS_PIPE_LISTENING
},
5630 { "PIPE_NOT_AVAILABLE", STATUS_PIPE_NOT_AVAILABLE
},
5631 { "PORT_NOT_SET", STATUS_PORT_NOT_SET
},
5632 { "PREDEFINED_HANDLE", STATUS_PREDEFINED_HANDLE
},
5633 { "PRIVILEGE_NOT_HELD", STATUS_PRIVILEGE_NOT_HELD
},
5634 { "PROCESS_IN_JOB", STATUS_PROCESS_IN_JOB
},
5635 { "PROCESS_IS_TERMINATING", STATUS_PROCESS_IS_TERMINATING
},
5636 { "PROCESS_NOT_IN_JOB", STATUS_PROCESS_NOT_IN_JOB
},
5637 { "REPARSE_POINT_NOT_RESOLVED", STATUS_REPARSE_POINT_NOT_RESOLVED
},
5638 { "SECTION_TOO_BIG", STATUS_SECTION_TOO_BIG
},
5639 { "SEMAPHORE_LIMIT_EXCEEDED", STATUS_SEMAPHORE_LIMIT_EXCEEDED
},
5640 { "SHARING_VIOLATION", STATUS_SHARING_VIOLATION
},
5641 { "SHUTDOWN_IN_PROGRESS", STATUS_SHUTDOWN_IN_PROGRESS
},
5642 { "SUSPEND_COUNT_EXCEEDED", STATUS_SUSPEND_COUNT_EXCEEDED
},
5643 { "THREAD_IS_TERMINATING", STATUS_THREAD_IS_TERMINATING
},
5644 { "TIMEOUT", STATUS_TIMEOUT
},
5645 { "TOO_MANY_OPENED_FILES", STATUS_TOO_MANY_OPENED_FILES
},
5646 { "UNSUCCESSFUL", STATUS_UNSUCCESSFUL
},
5647 { "USER_APC", STATUS_USER_APC
},
5648 { "USER_MAPPED_FILE", STATUS_USER_MAPPED_FILE
},
5649 { "VOLUME_DISMOUNTED", STATUS_VOLUME_DISMOUNTED
},
5650 { "WAS_LOCKED", STATUS_WAS_LOCKED
},
5651 { "WSAEACCES", 0xc0010000 | WSAEACCES
},
5652 { "WSAEADDRINUSE", 0xc0010000 | WSAEADDRINUSE
},
5653 { "WSAEADDRNOTAVAIL", 0xc0010000 | WSAEADDRNOTAVAIL
},
5654 { "WSAEAFNOSUPPORT", 0xc0010000 | WSAEAFNOSUPPORT
},
5655 { "WSAEALREADY", 0xc0010000 | WSAEALREADY
},
5656 { "WSAEBADF", 0xc0010000 | WSAEBADF
},
5657 { "WSAECONNABORTED", 0xc0010000 | WSAECONNABORTED
},
5658 { "WSAECONNREFUSED", 0xc0010000 | WSAECONNREFUSED
},
5659 { "WSAECONNRESET", 0xc0010000 | WSAECONNRESET
},
5660 { "WSAEDESTADDRREQ", 0xc0010000 | WSAEDESTADDRREQ
},
5661 { "WSAEDQUOT", 0xc0010000 | WSAEDQUOT
},
5662 { "WSAEFAULT", 0xc0010000 | WSAEFAULT
},
5663 { "WSAEHOSTDOWN", 0xc0010000 | WSAEHOSTDOWN
},
5664 { "WSAEHOSTUNREACH", 0xc0010000 | WSAEHOSTUNREACH
},
5665 { "WSAEINTR", 0xc0010000 | WSAEINTR
},
5666 { "WSAEINVAL", 0xc0010000 | WSAEINVAL
},
5667 { "WSAEISCONN", 0xc0010000 | WSAEISCONN
},
5668 { "WSAELOOP", 0xc0010000 | WSAELOOP
},
5669 { "WSAEMFILE", 0xc0010000 | WSAEMFILE
},
5670 { "WSAEMSGSIZE", 0xc0010000 | WSAEMSGSIZE
},
5671 { "WSAENAMETOOLONG", 0xc0010000 | WSAENAMETOOLONG
},
5672 { "WSAENETDOWN", 0xc0010000 | WSAENETDOWN
},
5673 { "WSAENETRESET", 0xc0010000 | WSAENETRESET
},
5674 { "WSAENETUNREACH", 0xc0010000 | WSAENETUNREACH
},
5675 { "WSAENOBUFS", 0xc0010000 | WSAENOBUFS
},
5676 { "WSAENOPROTOOPT", 0xc0010000 | WSAENOPROTOOPT
},
5677 { "WSAENOTCONN", 0xc0010000 | WSAENOTCONN
},
5678 { "WSAENOTEMPTY", 0xc0010000 | WSAENOTEMPTY
},
5679 { "WSAENOTSOCK", 0xc0010000 | WSAENOTSOCK
},
5680 { "WSAEOPNOTSUPP", 0xc0010000 | WSAEOPNOTSUPP
},
5681 { "WSAEPFNOSUPPORT", 0xc0010000 | WSAEPFNOSUPPORT
},
5682 { "WSAEPROCLIM", 0xc0010000 | WSAEPROCLIM
},
5683 { "WSAEPROTONOSUPPORT", 0xc0010000 | WSAEPROTONOSUPPORT
},
5684 { "WSAEPROTOTYPE", 0xc0010000 | WSAEPROTOTYPE
},
5685 { "WSAEREMOTE", 0xc0010000 | WSAEREMOTE
},
5686 { "WSAESHUTDOWN", 0xc0010000 | WSAESHUTDOWN
},
5687 { "WSAESOCKTNOSUPPORT", 0xc0010000 | WSAESOCKTNOSUPPORT
},
5688 { "WSAESTALE", 0xc0010000 | WSAESTALE
},
5689 { "WSAETIMEDOUT", 0xc0010000 | WSAETIMEDOUT
},
5690 { "WSAETOOMANYREFS", 0xc0010000 | WSAETOOMANYREFS
},
5691 { "WSAEUSERS", 0xc0010000 | WSAEUSERS
},
5692 { "WSAEWOULDBLOCK", 0xc0010000 | WSAEWOULDBLOCK
},
5696 /* ### make_requests end ### */
5697 /* Everything above this line is generated automatically by tools/make_requests */
5699 static const char *get_status_name( unsigned int status
)
5702 static char buffer
[10];
5706 for (i
= 0; status_names
[i
].name
; i
++)
5707 if (status_names
[i
].value
== status
) return status_names
[i
].name
;
5709 snprintf( buffer
, sizeof(buffer
), "%x", status
);
5713 void trace_request(void)
5715 enum request req
= current
->req
.request_header
.req
;
5716 if (req
< REQ_NB_REQUESTS
)
5718 fprintf( stderr
, "%04x: %s(", current
->id
, req_names
[req
] );
5719 if (req_dumpers
[req
])
5721 cur_data
= get_req_data();
5722 cur_size
= get_req_data_size();
5723 req_dumpers
[req
]( ¤t
->req
);
5725 fprintf( stderr
, " )\n" );
5727 else fprintf( stderr
, "%04x: %d(?)\n", current
->id
, req
);
5730 void trace_reply( enum request req
, const union generic_reply
*reply
)
5732 if (req
< REQ_NB_REQUESTS
)
5734 fprintf( stderr
, "%04x: %s() = %s",
5735 current
->id
, req_names
[req
], get_status_name(current
->error
) );
5736 if (reply_dumpers
[req
])
5738 fprintf( stderr
, " {" );
5739 cur_data
= current
->reply_data
;
5740 cur_size
= reply
->reply_header
.reply_size
;
5741 reply_dumpers
[req
]( reply
);
5742 fprintf( stderr
, " }" );
5744 fputc( '\n', stderr
);
5746 else fprintf( stderr
, "%04x: %d() = %s\n",
5747 current
->id
, req
, get_status_name(current
->error
) );