server: Limit the number of allocated handles before running out of memory.
[wine/wine64.git] / server / trace.c
blobdfbddacbd2975000b82df5498d8b082ce7b5922d
1 /*
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
21 #include "config.h"
22 #include "wine/port.h"
24 #include <ctype.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include <sys/types.h>
29 #ifdef HAVE_SYS_UIO_H
30 #include <sys/uio.h>
31 #endif
33 #include "ntstatus.h"
34 #define WIN32_NO_STATUS
35 #include "windef.h"
36 #include "winbase.h"
37 #include "wincon.h"
38 #include "winternl.h"
39 #include "winioctl.h"
40 #include "file.h"
41 #include "request.h"
42 #include "unicode.h"
44 static const void *cur_data;
45 static data_size_t cur_size;
47 static const char *get_status_name( unsigned int status );
49 /* utility functions */
51 static inline void remove_data( data_size_t size )
53 cur_data = (const char *)cur_data + size;
54 cur_size -= size;
57 static void dump_uints( const int *ptr, int len )
59 fputc( '{', stderr );
60 while (len > 0)
62 fprintf( stderr, "%08x", *ptr++ );
63 if (--len) fputc( ',', stderr );
65 fputc( '}', stderr );
68 static void dump_timeout( const timeout_t *time )
70 fprintf( stderr, get_timeout_str(*time) );
73 static void dump_file_pos( const file_pos_t *pos )
75 fprintf( stderr, "%x%08x", (unsigned int)(*pos >> 32), (unsigned int)*pos );
78 static void dump_rectangle( const rectangle_t *rect )
80 fprintf( stderr, "{%d,%d;%d,%d}",
81 rect->left, rect->top, rect->right, rect->bottom );
84 static void dump_char_info( const char_info_t *info )
86 fprintf( stderr, "{'" );
87 dump_strW( &info->ch, 1, stderr, "\'\'" );
88 fprintf( stderr, "',%04x}", info->attr );
91 static void dump_ioctl_code( const ioctl_code_t *code )
93 switch(*code)
95 #define CASE(c) case c: fputs( #c, stderr ); break
96 CASE(FSCTL_DISMOUNT_VOLUME);
97 CASE(FSCTL_PIPE_DISCONNECT);
98 CASE(FSCTL_PIPE_LISTEN);
99 CASE(FSCTL_PIPE_WAIT);
100 default: fprintf( stderr, "%08x", *code ); break;
101 #undef CASE
105 static void dump_apc_call( const apc_call_t *call )
107 fputc( '{', stderr );
108 switch(call->type)
110 case APC_NONE:
111 fprintf( stderr, "APC_NONE" );
112 break;
113 case APC_USER:
114 fprintf( stderr, "APC_USER,args={%lx,%lx,%lx}",
115 call->user.args[0], call->user.args[1], call->user.args[2] );
116 break;
117 case APC_TIMER:
118 fprintf( stderr, "APC_TIMER,time=" );
119 dump_timeout( &call->timer.time );
120 fprintf( stderr, ",arg=%p", call->timer.arg );
121 break;
122 case APC_ASYNC_IO:
123 fprintf( stderr, "APC_ASYNC_IO,func=%p,user=%p,sb=%p,status=%s",
124 call->async_io.func, call->async_io.user, call->async_io.sb,
125 get_status_name(call->async_io.status) );
126 break;
127 case APC_VIRTUAL_ALLOC:
128 fprintf( stderr, "APC_VIRTUAL_ALLOC,addr=%p,size=%lu,zero_bits=%u,op_type=%x,prot=%x",
129 call->virtual_alloc.addr, call->virtual_alloc.size,
130 call->virtual_alloc.zero_bits, call->virtual_alloc.op_type,
131 call->virtual_alloc.prot );
132 break;
133 case APC_VIRTUAL_FREE:
134 fprintf( stderr, "APC_VIRTUAL_FREE,addr=%p,size=%lu,op_type=%x",
135 call->virtual_free.addr, call->virtual_free.size,
136 call->virtual_free.op_type );
137 break;
138 case APC_VIRTUAL_QUERY:
139 fprintf( stderr, "APC_VIRTUAL_QUERY,addr=%p", call->virtual_query.addr );
140 break;
141 case APC_VIRTUAL_PROTECT:
142 fprintf( stderr, "APC_VIRTUAL_PROTECT,addr=%p,size=%lu,prot=%x",
143 call->virtual_protect.addr, call->virtual_protect.size,
144 call->virtual_protect.prot );
145 break;
146 case APC_VIRTUAL_FLUSH:
147 fprintf( stderr, "APC_VIRTUAL_FLUSH,addr=%p,size=%lu",
148 call->virtual_flush.addr, call->virtual_flush.size );
149 break;
150 case APC_VIRTUAL_LOCK:
151 fprintf( stderr, "APC_VIRTUAL_LOCK,addr=%p,size=%lu",
152 call->virtual_lock.addr, call->virtual_lock.size );
153 break;
154 case APC_VIRTUAL_UNLOCK:
155 fprintf( stderr, "APC_VIRTUAL_UNLOCK,addr=%p,size=%lu",
156 call->virtual_unlock.addr, call->virtual_unlock.size );
157 break;
158 case APC_MAP_VIEW:
159 fprintf( stderr, "APC_MAP_VIEW,handle=%p,addr=%p,size=%lu,offset=%x%08x,zero_bits=%u,alloc_type=%x,prot=%x",
160 call->map_view.handle, call->map_view.addr, call->map_view.size,
161 (unsigned int)(call->map_view.offset >> 32), (unsigned int)call->map_view.offset,
162 call->map_view.zero_bits, call->map_view.alloc_type, call->map_view.prot );
163 break;
164 case APC_UNMAP_VIEW:
165 fprintf( stderr, "APC_UNMAP_VIEW,addr=%p", call->unmap_view.addr );
166 break;
167 case APC_CREATE_THREAD:
168 fprintf( stderr, "APC_CREATE_THREAD,func=%p,arg=%p,reserve=%lx,commit=%lx,suspend=%u",
169 call->create_thread.func, call->create_thread.arg,
170 call->create_thread.reserve, call->create_thread.commit,
171 call->create_thread.suspend );
172 break;
173 default:
174 fprintf( stderr, "type=%u", call->type );
175 break;
177 fputc( '}', stderr );
180 static void dump_apc_result( const apc_result_t *result )
182 fputc( '{', stderr );
183 switch(result->type)
185 case APC_NONE:
186 break;
187 case APC_ASYNC_IO:
188 fprintf( stderr, "APC_ASYNC_IO,status=%s",
189 get_status_name( result->async_io.status ) );
190 break;
191 case APC_VIRTUAL_ALLOC:
192 fprintf( stderr, "APC_VIRTUAL_ALLOC,status=%s,addr=%p,size=%lu",
193 get_status_name( result->virtual_alloc.status ),
194 result->virtual_alloc.addr, result->virtual_alloc.size );
195 break;
196 case APC_VIRTUAL_FREE:
197 fprintf( stderr, "APC_VIRTUAL_FREE,status=%s,addr=%p,size=%lu",
198 get_status_name( result->virtual_free.status ),
199 result->virtual_free.addr, result->virtual_free.size );
200 break;
201 case APC_VIRTUAL_QUERY:
202 fprintf( stderr, "APC_VIRTUAL_QUERY,status=%s,base=%p,alloc_base=%p,size=%lu,state=%x,prot=%x,alloc_prot=%x,alloc_type=%x",
203 get_status_name( result->virtual_query.status ),
204 result->virtual_query.base, result->virtual_query.alloc_base,
205 result->virtual_query.size, result->virtual_query.state,
206 result->virtual_query.prot, result->virtual_query.alloc_prot,
207 result->virtual_query.alloc_type );
208 break;
209 case APC_VIRTUAL_PROTECT:
210 fprintf( stderr, "APC_VIRTUAL_PROTECT,status=%s,addr=%p,size=%lu,prot=%x",
211 get_status_name( result->virtual_protect.status ),
212 result->virtual_protect.addr, result->virtual_protect.size,
213 result->virtual_protect.prot );
214 break;
215 case APC_VIRTUAL_FLUSH:
216 fprintf( stderr, "APC_VIRTUAL_FLUSH,status=%s,addr=%p,size=%lu",
217 get_status_name( result->virtual_flush.status ),
218 result->virtual_flush.addr, result->virtual_flush.size );
219 break;
220 case APC_VIRTUAL_LOCK:
221 fprintf( stderr, "APC_VIRTUAL_LOCK,status=%s,addr=%p,size=%lu",
222 get_status_name( result->virtual_lock.status ),
223 result->virtual_lock.addr, result->virtual_lock.size );
224 break;
225 case APC_VIRTUAL_UNLOCK:
226 fprintf( stderr, "APC_VIRTUAL_UNLOCK,status=%s,addr=%p,size=%lu",
227 get_status_name( result->virtual_unlock.status ),
228 result->virtual_unlock.addr, result->virtual_unlock.size );
229 break;
230 case APC_MAP_VIEW:
231 fprintf( stderr, "APC_MAP_VIEW,status=%s,addr=%p,size=%lu",
232 get_status_name( result->map_view.status ),
233 result->map_view.addr, result->map_view.size );
234 break;
235 case APC_UNMAP_VIEW:
236 fprintf( stderr, "APC_UNMAP_VIEW,status=%s",
237 get_status_name( result->unmap_view.status ) );
238 break;
239 case APC_CREATE_THREAD:
240 fprintf( stderr, "APC_CREATE_THREAD,status=%s,tid=%04x,handle=%p",
241 get_status_name( result->create_thread.status ),
242 result->create_thread.tid, result->create_thread.handle );
243 break;
244 default:
245 fprintf( stderr, "type=%u", result->type );
246 break;
248 fputc( '}', stderr );
251 static void dump_async_data( const async_data_t *data )
253 fprintf( stderr, "{callback=%p,iosb=%p,arg=%p,apc=%p,event=%p}",
254 data->callback, data->iosb, data->arg, data->apc, data->event );
257 static void dump_luid( const luid_t *luid )
259 fprintf( stderr, "%d.%u", luid->high_part, luid->low_part );
262 static void dump_context( const CONTEXT *context, data_size_t size )
264 CONTEXT ctx;
266 memset( &ctx, 0, sizeof(ctx) );
267 memcpy( &ctx, context, min( size, sizeof(CONTEXT) ));
268 #ifdef __i386__
269 fprintf( stderr, "{flags=%08x,eax=%08x,ebx=%08x,ecx=%08x,edx=%08x,esi=%08x,edi=%08x,"
270 "ebp=%08x,eip=%08x,esp=%08x,eflags=%08x,cs=%04x,ds=%04x,es=%04x,"
271 "fs=%04x,gs=%04x,dr0=%08x,dr1=%08x,dr2=%08x,dr3=%08x,dr6=%08x,dr7=%08x,",
272 ctx.ContextFlags, ctx.Eax, ctx.Ebx, ctx.Ecx, ctx.Edx,
273 ctx.Esi, ctx.Edi, ctx.Ebp, ctx.Eip, ctx.Esp, ctx.EFlags,
274 ctx.SegCs, ctx.SegDs, ctx.SegEs, ctx.SegFs, ctx.SegGs,
275 ctx.Dr0, ctx.Dr1, ctx.Dr2, ctx.Dr3, ctx.Dr6, ctx.Dr7 );
276 fprintf( stderr, "float=" );
277 dump_uints( (const int *)&ctx.FloatSave, sizeof(ctx.FloatSave) / sizeof(int) );
278 if (size > FIELD_OFFSET( CONTEXT, ExtendedRegisters ))
280 fprintf( stderr, ",extended=" );
281 dump_uints( (const int *)&ctx.ExtendedRegisters, sizeof(ctx.ExtendedRegisters) / sizeof(int) );
283 fprintf( stderr, "}" );
284 #else
285 dump_uints( (const int *)&ctx, sizeof(ctx) / sizeof(int) );
286 #endif
289 static void dump_exc_record( const EXCEPTION_RECORD *rec )
291 unsigned int i;
292 fprintf( stderr, "{code=%x,flags=%x,rec=%p,addr=%p,params={",
293 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionRecord,
294 rec->ExceptionAddress );
295 for (i = 0; i < min(rec->NumberParameters,EXCEPTION_MAXIMUM_PARAMETERS); i++)
297 if (i) fputc( ',', stderr );
298 fprintf( stderr, "%lx", rec->ExceptionInformation[i] );
300 fputc( '}', stderr );
303 static void dump_varargs_ints( data_size_t size )
305 const int *data = cur_data;
306 data_size_t len = size / sizeof(*data);
308 fputc( '{', stderr );
309 while (len > 0)
311 fprintf( stderr, "%d", *data++ );
312 if (--len) fputc( ',', stderr );
314 fputc( '}', stderr );
315 remove_data( size );
318 static void dump_varargs_apc_result( data_size_t size )
320 const apc_result_t *result = cur_data;
322 if (size >= sizeof(*result))
324 dump_apc_result( result );
325 size = sizeof(*result);
327 remove_data( size );
330 static void dump_varargs_handles( data_size_t size )
332 const obj_handle_t *data = cur_data;
333 data_size_t len = size / sizeof(*data);
335 fputc( '{', stderr );
336 while (len > 0)
338 fprintf( stderr, "%p", *data++ );
339 if (--len) fputc( ',', stderr );
341 fputc( '}', stderr );
342 remove_data( size );
345 static void dump_varargs_user_handles( data_size_t size )
347 const user_handle_t *data = cur_data;
348 data_size_t len = size / sizeof(*data);
350 fputc( '{', stderr );
351 while (len > 0)
353 fprintf( stderr, "%p", *data++ );
354 if (--len) fputc( ',', stderr );
356 fputc( '}', stderr );
357 remove_data( size );
360 static void dump_varargs_bytes( data_size_t size )
362 const unsigned char *data = cur_data;
363 data_size_t len = size;
365 fputc( '{', stderr );
366 while (len > 0)
368 fprintf( stderr, "%02x", *data++ );
369 if (--len) fputc( ',', stderr );
371 fputc( '}', stderr );
372 remove_data( size );
375 static void dump_varargs_string( data_size_t size )
377 fprintf( stderr, "\"%.*s\"", (int)size, (const char *)cur_data );
378 remove_data( size );
381 static void dump_varargs_unicode_str( data_size_t size )
383 fprintf( stderr, "L\"" );
384 dump_strW( cur_data, size / sizeof(WCHAR), stderr, "\"\"" );
385 fputc( '\"', stderr );
386 remove_data( size );
389 static void dump_varargs_context( data_size_t size )
391 if (!size)
393 fprintf( stderr, "{}" );
394 return;
396 dump_context( cur_data, size );
397 remove_data( min( size, sizeof(CONTEXT) ));
400 static void dump_varargs_exc_event( data_size_t size )
402 const CONTEXT *ptr = cur_data;
404 if (!size)
406 fprintf( stderr, "{}" );
407 return;
409 fprintf( stderr, "{context=" );
410 dump_context( ptr, size );
411 if (size > sizeof(CONTEXT))
413 fprintf( stderr, ",rec=" );
414 dump_exc_record( (const EXCEPTION_RECORD *)(ptr + 1) );
416 fputc( '}', stderr );
417 remove_data( size );
420 static void dump_varargs_debug_event( data_size_t size )
422 const debug_event_t *event = cur_data;
424 if (!size)
426 fprintf( stderr, "{}" );
427 return;
429 switch(event->code)
431 case EXCEPTION_DEBUG_EVENT:
432 fprintf( stderr, "{exception," );
433 dump_exc_record( &event->info.exception.record );
434 fprintf( stderr, ",first=%d}", event->info.exception.first );
435 break;
436 case CREATE_THREAD_DEBUG_EVENT:
437 fprintf( stderr, "{create_thread,thread=%p,teb=%p,start=%p}",
438 event->info.create_thread.handle, event->info.create_thread.teb,
439 event->info.create_thread.start );
440 break;
441 case CREATE_PROCESS_DEBUG_EVENT:
442 fprintf( stderr, "{create_process,file=%p,process=%p,thread=%p,base=%p,offset=%d,"
443 "size=%d,teb=%p,start=%p,name=%p,unicode=%d}",
444 event->info.create_process.file, event->info.create_process.process,
445 event->info.create_process.thread, event->info.create_process.base,
446 event->info.create_process.dbg_offset, event->info.create_process.dbg_size,
447 event->info.create_process.teb, event->info.create_process.start,
448 event->info.create_process.name, event->info.create_process.unicode );
449 break;
450 case EXIT_THREAD_DEBUG_EVENT:
451 fprintf( stderr, "{exit_thread,code=%d}", event->info.exit.exit_code );
452 break;
453 case EXIT_PROCESS_DEBUG_EVENT:
454 fprintf( stderr, "{exit_process,code=%d}", event->info.exit.exit_code );
455 break;
456 case LOAD_DLL_DEBUG_EVENT:
457 fprintf( stderr, "{load_dll,file=%p,base=%p,offset=%d,size=%d,name=%p,unicode=%d}",
458 event->info.load_dll.handle, event->info.load_dll.base,
459 event->info.load_dll.dbg_offset, event->info.load_dll.dbg_size,
460 event->info.load_dll.name, event->info.load_dll.unicode );
461 break;
462 case UNLOAD_DLL_DEBUG_EVENT:
463 fprintf( stderr, "{unload_dll,base=%p}", event->info.unload_dll.base );
464 break;
465 case OUTPUT_DEBUG_STRING_EVENT:
466 fprintf( stderr, "{output_string,data=%p,unicode=%d,len=%d}",
467 event->info.output_string.string, event->info.output_string.unicode,
468 event->info.output_string.length );
469 break;
470 case RIP_EVENT:
471 fprintf( stderr, "{rip,err=%d,type=%d}",
472 event->info.rip_info.error, event->info.rip_info.type );
473 break;
474 case 0: /* zero is the code returned on timeouts */
475 fprintf( stderr, "{}" );
476 break;
477 default:
478 fprintf( stderr, "{code=??? (%d)}", event->code );
479 break;
481 remove_data( size );
484 /* dump a unicode string contained in a buffer; helper for dump_varargs_startup_info */
485 static void dump_inline_unicode_string( const UNICODE_STRING *str, const void *data, data_size_t size )
487 size_t length = str->Length;
488 size_t offset = (size_t)str->Buffer;
490 if (offset >= size) return;
491 if (offset + length > size) length = size - offset;
492 dump_strW( (const WCHAR *)data + offset/sizeof(WCHAR), length/sizeof(WCHAR), stderr, "\"\"" );
495 static void dump_varargs_startup_info( data_size_t size )
497 const RTL_USER_PROCESS_PARAMETERS *ptr = cur_data;
498 RTL_USER_PROCESS_PARAMETERS params;
500 if (size < sizeof(params.Size))
502 fprintf( stderr, "{}" );
503 return;
505 if (size > ptr->Size) size = ptr->Size;
506 memset( &params, 0, sizeof(params) );
507 memcpy( &params, ptr, min( size, sizeof(params) ));
509 fprintf( stderr, "{AllocationSize=%x,", params.AllocationSize );
510 fprintf( stderr, "Size=%x,", params.Size );
511 fprintf( stderr, "Flags=%x,", params.Flags );
512 fprintf( stderr, "DebugFlags=%x,", params.DebugFlags );
513 fprintf( stderr, "ConsoleHandle=%p,", params.ConsoleHandle );
514 fprintf( stderr, "ConsoleFlags=%x,", params.ConsoleFlags );
515 fprintf( stderr, "hStdInput=%p,", params.hStdInput );
516 fprintf( stderr, "hStdOutput=%p,", params.hStdOutput );
517 fprintf( stderr, "hStdError=%p,", params.hStdError );
518 fprintf( stderr, "CurrentDirectory.Handle=%p,", params.CurrentDirectory.Handle );
519 fprintf( stderr, "dwX=%d,", params.dwX );
520 fprintf( stderr, "dwY=%d,", params.dwY );
521 fprintf( stderr, "dwXSize=%d,", params.dwXSize );
522 fprintf( stderr, "dwYSize=%d,", params.dwYSize );
523 fprintf( stderr, "dwXCountChars=%d,", params.dwXCountChars );
524 fprintf( stderr, "dwYCountChars=%d,", params.dwYCountChars );
525 fprintf( stderr, "dwFillAttribute=%x,", params.dwFillAttribute );
526 fprintf( stderr, "dwFlags=%x,", params.dwFlags );
527 fprintf( stderr, "wShowWindow=%x,", params.wShowWindow );
528 fprintf( stderr, "CurrentDirectory.DosPath=L\"" );
529 dump_inline_unicode_string( &params.CurrentDirectory.DosPath, cur_data, size );
530 fprintf( stderr, "\",DllPath=L\"" );
531 dump_inline_unicode_string( &params.DllPath, cur_data, size );
532 fprintf( stderr, "\",ImagePathName=L\"" );
533 dump_inline_unicode_string( &params.ImagePathName, cur_data, size );
534 fprintf( stderr, "\",CommandLine=L\"" );
535 dump_inline_unicode_string( &params.CommandLine, cur_data, size );
536 fprintf( stderr, "\",WindowTitle=L\"" );
537 dump_inline_unicode_string( &params.WindowTitle, cur_data, size );
538 fprintf( stderr, "\",Desktop=L\"" );
539 dump_inline_unicode_string( &params.Desktop, cur_data, size );
540 fprintf( stderr, "\",ShellInfo=L\"" );
541 dump_inline_unicode_string( &params.ShellInfo, cur_data, size );
542 fprintf( stderr, "\",RuntimeInfo=L\"" );
543 dump_inline_unicode_string( &params.RuntimeInfo, cur_data, size );
544 fprintf( stderr, "\"}" );
545 remove_data( size );
548 static void dump_varargs_input_records( data_size_t size )
550 const INPUT_RECORD *rec = cur_data;
551 data_size_t len = size / sizeof(*rec);
553 fputc( '{', stderr );
554 while (len > 0)
556 fprintf( stderr, "{%04x,...}", rec->EventType );
557 rec++;
558 if (--len) fputc( ',', stderr );
560 fputc( '}', stderr );
561 remove_data( size );
564 static void dump_varargs_rectangles( data_size_t size )
566 const rectangle_t *rect = cur_data;
567 data_size_t len = size / sizeof(*rect);
569 fputc( '{', stderr );
570 while (len > 0)
572 dump_rectangle( rect++ );
573 if (--len) fputc( ',', stderr );
575 fputc( '}', stderr );
576 remove_data( size );
579 static void dump_varargs_message_data( data_size_t size )
581 /* FIXME: dump the structured data */
582 dump_varargs_bytes( size );
585 static void dump_varargs_properties( data_size_t size )
587 const property_data_t *prop = cur_data;
588 data_size_t len = size / sizeof(*prop);
590 fputc( '{', stderr );
591 while (len > 0)
593 fprintf( stderr, "{atom=%04x,str=%d,handle=%p}",
594 prop->atom, prop->string, prop->handle );
595 prop++;
596 if (--len) fputc( ',', stderr );
598 fputc( '}', stderr );
599 remove_data( size );
602 static void dump_varargs_LUID_AND_ATTRIBUTES( data_size_t size )
604 const LUID_AND_ATTRIBUTES *lat = cur_data;
605 data_size_t len = size / sizeof(*lat);
607 fputc( '{', stderr );
608 while (len > 0)
610 fprintf( stderr, "{luid=%08x%08x,attr=%x}",
611 lat->Luid.HighPart, lat->Luid.LowPart, lat->Attributes );
612 lat++;
613 if (--len) fputc( ',', stderr );
615 fputc( '}', stderr );
616 remove_data( size );
619 static void dump_inline_sid( const SID *sid, data_size_t size )
621 DWORD i;
623 /* security check */
624 if ((FIELD_OFFSET(SID, SubAuthority[0]) > size) ||
625 (FIELD_OFFSET(SID, SubAuthority[sid->SubAuthorityCount]) > size))
627 fprintf( stderr, "<invalid sid>" );
628 return;
631 fputc( '{', stderr );
632 fprintf( stderr, "S-%u-%u", sid->Revision, MAKELONG(
633 MAKEWORD( sid->IdentifierAuthority.Value[5],
634 sid->IdentifierAuthority.Value[4] ),
635 MAKEWORD( sid->IdentifierAuthority.Value[3],
636 sid->IdentifierAuthority.Value[2] ) ) );
637 for (i = 0; i < sid->SubAuthorityCount; i++)
638 fprintf( stderr, "-%u", sid->SubAuthority[i] );
639 fputc( '}', stderr );
642 static void dump_varargs_SID( data_size_t size )
644 const SID *sid = cur_data;
645 dump_inline_sid( sid, size );
646 remove_data( size );
649 static void dump_inline_acl( const ACL *acl, data_size_t size )
651 const ACE_HEADER *ace;
652 ULONG i;
653 fputc( '{', stderr );
655 if (size)
657 if (size < sizeof(ACL))
659 fprintf( stderr, "<invalid acl>}\n" );
660 return;
662 size -= sizeof(ACL);
663 ace = (const ACE_HEADER *)(acl + 1);
664 for (i = 0; i < acl->AceCount; i++)
666 const SID *sid = NULL;
667 data_size_t sid_size = 0;
669 if (size < sizeof(ACE_HEADER))
670 return;
671 if (size < ace->AceSize)
672 return;
673 size -= ace->AceSize;
674 if (i != 0) fputc( ',', stderr );
675 fprintf( stderr, "{AceType=" );
676 switch (ace->AceType)
678 case ACCESS_DENIED_ACE_TYPE:
679 sid = (const SID *)&((const ACCESS_DENIED_ACE *)ace)->SidStart;
680 sid_size = ace->AceSize - FIELD_OFFSET(ACCESS_DENIED_ACE, SidStart);
681 fprintf( stderr, "ACCESS_DENIED_ACE_TYPE,Mask=%x",
682 ((const ACCESS_DENIED_ACE *)ace)->Mask );
683 break;
684 case ACCESS_ALLOWED_ACE_TYPE:
685 sid = (const SID *)&((const ACCESS_ALLOWED_ACE *)ace)->SidStart;
686 sid_size = ace->AceSize - FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart);
687 fprintf( stderr, "ACCESS_ALLOWED_ACE_TYPE,Mask=%x",
688 ((const ACCESS_ALLOWED_ACE *)ace)->Mask );
689 break;
690 case SYSTEM_AUDIT_ACE_TYPE:
691 sid = (const SID *)&((const SYSTEM_AUDIT_ACE *)ace)->SidStart;
692 sid_size = ace->AceSize - FIELD_OFFSET(SYSTEM_AUDIT_ACE, SidStart);
693 fprintf( stderr, "SYSTEM_AUDIT_ACE_TYPE,Mask=%x",
694 ((const SYSTEM_AUDIT_ACE *)ace)->Mask );
695 break;
696 case SYSTEM_ALARM_ACE_TYPE:
697 sid = (const SID *)&((const SYSTEM_ALARM_ACE *)ace)->SidStart;
698 sid_size = ace->AceSize - FIELD_OFFSET(SYSTEM_ALARM_ACE, SidStart);
699 fprintf( stderr, "SYSTEM_ALARM_ACE_TYPE,Mask=%x",
700 ((const SYSTEM_ALARM_ACE *)ace)->Mask );
701 break;
702 default:
703 fprintf( stderr, "unknown<%d>", ace->AceType );
704 break;
706 fprintf( stderr, ",AceFlags=%x,Sid=", ace->AceFlags );
707 if (sid)
708 dump_inline_sid( sid, sid_size );
709 ace = (const ACE_HEADER *)((const char *)ace + ace->AceSize);
710 fputc( '}', stderr );
713 fputc( '}', stderr );
716 static void dump_inline_security_descriptor( const struct security_descriptor *sd, data_size_t size )
718 fputc( '{', stderr );
719 if (size >= sizeof(struct security_descriptor))
721 size_t offset = sizeof(struct security_descriptor);
722 fprintf( stderr, "control=%08x", sd->control );
723 fprintf( stderr, ",owner=" );
724 if ((sd->owner_len > FIELD_OFFSET(SID, SubAuthority[255])) || (offset + sd->owner_len > size))
725 return;
726 if (sd->owner_len)
727 dump_inline_sid( (const SID *)((const char *)sd + offset), sd->owner_len );
728 else
729 fprintf( stderr, "<not present>" );
730 offset += sd->owner_len;
731 fprintf( stderr, ",group=" );
732 if ((sd->group_len > FIELD_OFFSET(SID, SubAuthority[255])) || (offset + sd->group_len > size))
733 return;
734 if (sd->group_len)
735 dump_inline_sid( (const SID *)((const char *)sd + offset), sd->group_len );
736 else
737 fprintf( stderr, "<not present>" );
738 offset += sd->group_len;
739 fprintf( stderr, ",sacl=" );
740 if ((sd->sacl_len >= MAX_ACL_LEN) || (offset + sd->sacl_len > size))
741 return;
742 dump_inline_acl( (const ACL *)((const char *)sd + offset), sd->sacl_len );
743 offset += sd->sacl_len;
744 fprintf( stderr, ",dacl=" );
745 if ((sd->dacl_len >= MAX_ACL_LEN) || (offset + sd->dacl_len > size))
746 return;
747 dump_inline_acl( (const ACL *)((const char *)sd + offset), sd->dacl_len );
748 offset += sd->dacl_len;
750 fputc( '}', stderr );
753 static void dump_varargs_security_descriptor( data_size_t size )
755 const struct security_descriptor *sd = cur_data;
756 dump_inline_security_descriptor( sd, size );
757 remove_data( size );
760 static void dump_varargs_token_groups( data_size_t size )
762 const struct token_groups *tg = cur_data;
763 fputc( '{', stderr );
764 if (size >= sizeof(struct token_groups))
766 size_t offset = sizeof(*tg);
767 fprintf( stderr, "count=%08x,", tg->count );
768 if (tg->count * sizeof(unsigned int) <= size)
770 unsigned int i;
771 const unsigned int *attr = (const unsigned int *)(tg + 1);
773 offset += tg->count * sizeof(unsigned int);
775 fputc( '[', stderr );
776 for (i = 0; i < tg->count; i++)
778 const SID *sid = (const SID *)((const char *)cur_data + offset);
779 if (i != 0)
780 fputc( ',', stderr );
781 fputc( '{', stderr );
782 fprintf( stderr, "attributes=%08x", attr[i] );
783 fprintf( stderr, ",sid=" );
784 dump_inline_sid( sid, size - offset );
785 if ((offset + FIELD_OFFSET(SID, SubAuthority[0]) > size) ||
786 (offset + FIELD_OFFSET(SID, SubAuthority[sid->SubAuthorityCount]) > size))
787 break;
788 offset += FIELD_OFFSET(SID, SubAuthority[sid->SubAuthorityCount]);
789 fputc( '}', stderr );
791 fputc( ']', stderr );
794 fputc( '}', stderr );
797 static void dump_varargs_object_attributes( data_size_t size )
799 const struct object_attributes *objattr = cur_data;
800 fputc( '{', stderr );
801 if (size >= sizeof(struct object_attributes))
803 const WCHAR *str;
804 fprintf( stderr, "rootdir=%p,sd=", objattr->rootdir );
805 if (objattr->sd_len > size - sizeof(*objattr) ||
806 objattr->name_len > size - sizeof(*objattr) - objattr->sd_len)
807 return;
808 dump_inline_security_descriptor( (const struct security_descriptor *)(objattr + 1), objattr->sd_len );
809 str = (const WCHAR *)objattr + (sizeof(*objattr) + objattr->sd_len) / sizeof(WCHAR);
810 fprintf( stderr, ",name=L\"" );
811 dump_strW( str, objattr->name_len / sizeof(WCHAR), stderr, "\"\"" );
812 fputc( '\"', stderr );
813 remove_data( ((sizeof(*objattr) + objattr->sd_len) / sizeof(WCHAR)) * sizeof(WCHAR) +
814 objattr->name_len );
816 fputc( '}', stderr );
819 typedef void (*dump_func)( const void *req );
821 /* Everything below this line is generated automatically by tools/make_requests */
822 /* ### make_requests begin ### */
824 static void dump_new_process_request( const struct new_process_request *req )
826 fprintf( stderr, " inherit_all=%d,", req->inherit_all );
827 fprintf( stderr, " create_flags=%08x,", req->create_flags );
828 fprintf( stderr, " socket_fd=%d,", req->socket_fd );
829 fprintf( stderr, " exe_file=%p,", req->exe_file );
830 fprintf( stderr, " hstdin=%p,", req->hstdin );
831 fprintf( stderr, " hstdout=%p,", req->hstdout );
832 fprintf( stderr, " hstderr=%p,", req->hstderr );
833 fprintf( stderr, " process_access=%08x,", req->process_access );
834 fprintf( stderr, " process_attr=%08x,", req->process_attr );
835 fprintf( stderr, " thread_access=%08x,", req->thread_access );
836 fprintf( stderr, " thread_attr=%08x,", req->thread_attr );
837 fprintf( stderr, " info=" );
838 dump_varargs_startup_info( cur_size );
839 fputc( ',', stderr );
840 fprintf( stderr, " env=" );
841 dump_varargs_unicode_str( cur_size );
844 static void dump_new_process_reply( const struct new_process_reply *req )
846 fprintf( stderr, " info=%p,", req->info );
847 fprintf( stderr, " pid=%04x,", req->pid );
848 fprintf( stderr, " phandle=%p,", req->phandle );
849 fprintf( stderr, " tid=%04x,", req->tid );
850 fprintf( stderr, " thandle=%p", req->thandle );
853 static void dump_get_new_process_info_request( const struct get_new_process_info_request *req )
855 fprintf( stderr, " info=%p", req->info );
858 static void dump_get_new_process_info_reply( const struct get_new_process_info_reply *req )
860 fprintf( stderr, " success=%d,", req->success );
861 fprintf( stderr, " exit_code=%d", req->exit_code );
864 static void dump_new_thread_request( const struct new_thread_request *req )
866 fprintf( stderr, " access=%08x,", req->access );
867 fprintf( stderr, " attributes=%08x,", req->attributes );
868 fprintf( stderr, " suspend=%d,", req->suspend );
869 fprintf( stderr, " request_fd=%d", req->request_fd );
872 static void dump_new_thread_reply( const struct new_thread_reply *req )
874 fprintf( stderr, " tid=%04x,", req->tid );
875 fprintf( stderr, " handle=%p", req->handle );
878 static void dump_get_startup_info_request( const struct get_startup_info_request *req )
882 static void dump_get_startup_info_reply( const struct get_startup_info_reply *req )
884 fprintf( stderr, " exe_file=%p,", req->exe_file );
885 fprintf( stderr, " hstdin=%p,", req->hstdin );
886 fprintf( stderr, " hstdout=%p,", req->hstdout );
887 fprintf( stderr, " hstderr=%p,", req->hstderr );
888 fprintf( stderr, " info=" );
889 dump_varargs_startup_info( cur_size );
890 fputc( ',', stderr );
891 fprintf( stderr, " env=" );
892 dump_varargs_unicode_str( cur_size );
895 static void dump_init_process_done_request( const struct init_process_done_request *req )
897 fprintf( stderr, " module=%p,", req->module );
898 fprintf( stderr, " entry=%p,", req->entry );
899 fprintf( stderr, " gui=%d", req->gui );
902 static void dump_init_thread_request( const struct init_thread_request *req )
904 fprintf( stderr, " unix_pid=%d,", req->unix_pid );
905 fprintf( stderr, " unix_tid=%d,", req->unix_tid );
906 fprintf( stderr, " debug_level=%d,", req->debug_level );
907 fprintf( stderr, " teb=%p,", req->teb );
908 fprintf( stderr, " peb=%p,", req->peb );
909 fprintf( stderr, " entry=%p,", req->entry );
910 fprintf( stderr, " ldt_copy=%p,", req->ldt_copy );
911 fprintf( stderr, " reply_fd=%d,", req->reply_fd );
912 fprintf( stderr, " wait_fd=%d", req->wait_fd );
915 static void dump_init_thread_reply( const struct init_thread_reply *req )
917 fprintf( stderr, " pid=%04x,", req->pid );
918 fprintf( stderr, " tid=%04x,", req->tid );
919 fprintf( stderr, " info_size=%u,", req->info_size );
920 fprintf( stderr, " server_start=" );
921 dump_timeout( &req->server_start );
922 fprintf( stderr, "," );
923 fprintf( stderr, " version=%d", req->version );
926 static void dump_terminate_process_request( const struct terminate_process_request *req )
928 fprintf( stderr, " handle=%p,", req->handle );
929 fprintf( stderr, " exit_code=%d", req->exit_code );
932 static void dump_terminate_process_reply( const struct terminate_process_reply *req )
934 fprintf( stderr, " self=%d", req->self );
937 static void dump_terminate_thread_request( const struct terminate_thread_request *req )
939 fprintf( stderr, " handle=%p,", req->handle );
940 fprintf( stderr, " exit_code=%d", req->exit_code );
943 static void dump_terminate_thread_reply( const struct terminate_thread_reply *req )
945 fprintf( stderr, " self=%d,", req->self );
946 fprintf( stderr, " last=%d", req->last );
949 static void dump_get_process_info_request( const struct get_process_info_request *req )
951 fprintf( stderr, " handle=%p", req->handle );
954 static void dump_get_process_info_reply( const struct get_process_info_reply *req )
956 fprintf( stderr, " pid=%04x,", req->pid );
957 fprintf( stderr, " ppid=%04x,", req->ppid );
958 fprintf( stderr, " exit_code=%d,", req->exit_code );
959 fprintf( stderr, " priority=%d,", req->priority );
960 fprintf( stderr, " affinity=%08x,", req->affinity );
961 fprintf( stderr, " peb=%p,", req->peb );
962 fprintf( stderr, " start_time=" );
963 dump_timeout( &req->start_time );
964 fprintf( stderr, "," );
965 fprintf( stderr, " end_time=" );
966 dump_timeout( &req->end_time );
969 static void dump_set_process_info_request( const struct set_process_info_request *req )
971 fprintf( stderr, " handle=%p,", req->handle );
972 fprintf( stderr, " mask=%d,", req->mask );
973 fprintf( stderr, " priority=%d,", req->priority );
974 fprintf( stderr, " affinity=%08x", req->affinity );
977 static void dump_get_thread_info_request( const struct get_thread_info_request *req )
979 fprintf( stderr, " handle=%p,", req->handle );
980 fprintf( stderr, " tid_in=%04x", req->tid_in );
983 static void dump_get_thread_info_reply( const struct get_thread_info_reply *req )
985 fprintf( stderr, " pid=%04x,", req->pid );
986 fprintf( stderr, " tid=%04x,", req->tid );
987 fprintf( stderr, " teb=%p,", req->teb );
988 fprintf( stderr, " exit_code=%d,", req->exit_code );
989 fprintf( stderr, " priority=%d,", req->priority );
990 fprintf( stderr, " affinity=%08x,", req->affinity );
991 fprintf( stderr, " creation_time=" );
992 dump_timeout( &req->creation_time );
993 fprintf( stderr, "," );
994 fprintf( stderr, " exit_time=" );
995 dump_timeout( &req->exit_time );
996 fprintf( stderr, "," );
997 fprintf( stderr, " last=%d", req->last );
1000 static void dump_set_thread_info_request( const struct set_thread_info_request *req )
1002 fprintf( stderr, " handle=%p,", req->handle );
1003 fprintf( stderr, " mask=%d,", req->mask );
1004 fprintf( stderr, " priority=%d,", req->priority );
1005 fprintf( stderr, " affinity=%08x,", req->affinity );
1006 fprintf( stderr, " token=%p", req->token );
1009 static void dump_get_dll_info_request( const struct get_dll_info_request *req )
1011 fprintf( stderr, " handle=%p,", req->handle );
1012 fprintf( stderr, " base_address=%p", req->base_address );
1015 static void dump_get_dll_info_reply( const struct get_dll_info_reply *req )
1017 fprintf( stderr, " size=%lu,", (unsigned long)req->size );
1018 fprintf( stderr, " entry_point=%p,", req->entry_point );
1019 fprintf( stderr, " filename_len=%u,", req->filename_len );
1020 fprintf( stderr, " filename=" );
1021 dump_varargs_unicode_str( cur_size );
1024 static void dump_suspend_thread_request( const struct suspend_thread_request *req )
1026 fprintf( stderr, " handle=%p", req->handle );
1029 static void dump_suspend_thread_reply( const struct suspend_thread_reply *req )
1031 fprintf( stderr, " count=%d", req->count );
1034 static void dump_resume_thread_request( const struct resume_thread_request *req )
1036 fprintf( stderr, " handle=%p", req->handle );
1039 static void dump_resume_thread_reply( const struct resume_thread_reply *req )
1041 fprintf( stderr, " count=%d", req->count );
1044 static void dump_load_dll_request( const struct load_dll_request *req )
1046 fprintf( stderr, " handle=%p,", req->handle );
1047 fprintf( stderr, " base=%p,", req->base );
1048 fprintf( stderr, " size=%lu,", (unsigned long)req->size );
1049 fprintf( stderr, " dbg_offset=%d,", req->dbg_offset );
1050 fprintf( stderr, " dbg_size=%d,", req->dbg_size );
1051 fprintf( stderr, " name=%p,", req->name );
1052 fprintf( stderr, " filename=" );
1053 dump_varargs_unicode_str( cur_size );
1056 static void dump_unload_dll_request( const struct unload_dll_request *req )
1058 fprintf( stderr, " base=%p", req->base );
1061 static void dump_queue_apc_request( const struct queue_apc_request *req )
1063 fprintf( stderr, " thread=%p,", req->thread );
1064 fprintf( stderr, " process=%p,", req->process );
1065 fprintf( stderr, " call=" );
1066 dump_apc_call( &req->call );
1069 static void dump_queue_apc_reply( const struct queue_apc_reply *req )
1071 fprintf( stderr, " handle=%p,", req->handle );
1072 fprintf( stderr, " self=%d", req->self );
1075 static void dump_get_apc_result_request( const struct get_apc_result_request *req )
1077 fprintf( stderr, " handle=%p", req->handle );
1080 static void dump_get_apc_result_reply( const struct get_apc_result_reply *req )
1082 fprintf( stderr, " result=" );
1083 dump_apc_result( &req->result );
1086 static void dump_close_handle_request( const struct close_handle_request *req )
1088 fprintf( stderr, " handle=%p", req->handle );
1091 static void dump_set_handle_info_request( const struct set_handle_info_request *req )
1093 fprintf( stderr, " handle=%p,", req->handle );
1094 fprintf( stderr, " flags=%d,", req->flags );
1095 fprintf( stderr, " mask=%d", req->mask );
1098 static void dump_set_handle_info_reply( const struct set_handle_info_reply *req )
1100 fprintf( stderr, " old_flags=%d", req->old_flags );
1103 static void dump_dup_handle_request( const struct dup_handle_request *req )
1105 fprintf( stderr, " src_process=%p,", req->src_process );
1106 fprintf( stderr, " src_handle=%p,", req->src_handle );
1107 fprintf( stderr, " dst_process=%p,", req->dst_process );
1108 fprintf( stderr, " access=%08x,", req->access );
1109 fprintf( stderr, " attributes=%08x,", req->attributes );
1110 fprintf( stderr, " options=%08x", req->options );
1113 static void dump_dup_handle_reply( const struct dup_handle_reply *req )
1115 fprintf( stderr, " handle=%p,", req->handle );
1116 fprintf( stderr, " self=%d,", req->self );
1117 fprintf( stderr, " closed=%d", req->closed );
1120 static void dump_open_process_request( const struct open_process_request *req )
1122 fprintf( stderr, " pid=%04x,", req->pid );
1123 fprintf( stderr, " access=%08x,", req->access );
1124 fprintf( stderr, " attributes=%08x", req->attributes );
1127 static void dump_open_process_reply( const struct open_process_reply *req )
1129 fprintf( stderr, " handle=%p", req->handle );
1132 static void dump_open_thread_request( const struct open_thread_request *req )
1134 fprintf( stderr, " tid=%04x,", req->tid );
1135 fprintf( stderr, " access=%08x,", req->access );
1136 fprintf( stderr, " attributes=%08x", req->attributes );
1139 static void dump_open_thread_reply( const struct open_thread_reply *req )
1141 fprintf( stderr, " handle=%p", req->handle );
1144 static void dump_select_request( const struct select_request *req )
1146 fprintf( stderr, " flags=%d,", req->flags );
1147 fprintf( stderr, " cookie=%p,", req->cookie );
1148 fprintf( stderr, " signal=%p,", req->signal );
1149 fprintf( stderr, " prev_apc=%p,", req->prev_apc );
1150 fprintf( stderr, " timeout=" );
1151 dump_timeout( &req->timeout );
1152 fprintf( stderr, "," );
1153 fprintf( stderr, " result=" );
1154 dump_varargs_apc_result( cur_size );
1155 fputc( ',', stderr );
1156 fprintf( stderr, " handles=" );
1157 dump_varargs_handles( cur_size );
1160 static void dump_select_reply( const struct select_reply *req )
1162 fprintf( stderr, " apc_handle=%p,", req->apc_handle );
1163 fprintf( stderr, " timeout=" );
1164 dump_timeout( &req->timeout );
1165 fprintf( stderr, "," );
1166 fprintf( stderr, " call=" );
1167 dump_apc_call( &req->call );
1170 static void dump_create_event_request( const struct create_event_request *req )
1172 fprintf( stderr, " access=%08x,", req->access );
1173 fprintf( stderr, " attributes=%08x,", req->attributes );
1174 fprintf( stderr, " manual_reset=%d,", req->manual_reset );
1175 fprintf( stderr, " initial_state=%d,", req->initial_state );
1176 fprintf( stderr, " objattr=" );
1177 dump_varargs_object_attributes( cur_size );
1180 static void dump_create_event_reply( const struct create_event_reply *req )
1182 fprintf( stderr, " handle=%p", req->handle );
1185 static void dump_event_op_request( const struct event_op_request *req )
1187 fprintf( stderr, " handle=%p,", req->handle );
1188 fprintf( stderr, " op=%d", req->op );
1191 static void dump_open_event_request( const struct open_event_request *req )
1193 fprintf( stderr, " access=%08x,", req->access );
1194 fprintf( stderr, " attributes=%08x,", req->attributes );
1195 fprintf( stderr, " rootdir=%p,", req->rootdir );
1196 fprintf( stderr, " name=" );
1197 dump_varargs_unicode_str( cur_size );
1200 static void dump_open_event_reply( const struct open_event_reply *req )
1202 fprintf( stderr, " handle=%p", req->handle );
1205 static void dump_create_mutex_request( const struct create_mutex_request *req )
1207 fprintf( stderr, " access=%08x,", req->access );
1208 fprintf( stderr, " attributes=%08x,", req->attributes );
1209 fprintf( stderr, " owned=%d,", req->owned );
1210 fprintf( stderr, " objattr=" );
1211 dump_varargs_object_attributes( cur_size );
1214 static void dump_create_mutex_reply( const struct create_mutex_reply *req )
1216 fprintf( stderr, " handle=%p", req->handle );
1219 static void dump_release_mutex_request( const struct release_mutex_request *req )
1221 fprintf( stderr, " handle=%p", req->handle );
1224 static void dump_release_mutex_reply( const struct release_mutex_reply *req )
1226 fprintf( stderr, " prev_count=%08x", req->prev_count );
1229 static void dump_open_mutex_request( const struct open_mutex_request *req )
1231 fprintf( stderr, " access=%08x,", req->access );
1232 fprintf( stderr, " attributes=%08x,", req->attributes );
1233 fprintf( stderr, " rootdir=%p,", req->rootdir );
1234 fprintf( stderr, " name=" );
1235 dump_varargs_unicode_str( cur_size );
1238 static void dump_open_mutex_reply( const struct open_mutex_reply *req )
1240 fprintf( stderr, " handle=%p", req->handle );
1243 static void dump_create_semaphore_request( const struct create_semaphore_request *req )
1245 fprintf( stderr, " access=%08x,", req->access );
1246 fprintf( stderr, " attributes=%08x,", req->attributes );
1247 fprintf( stderr, " initial=%08x,", req->initial );
1248 fprintf( stderr, " max=%08x,", req->max );
1249 fprintf( stderr, " objattr=" );
1250 dump_varargs_object_attributes( cur_size );
1253 static void dump_create_semaphore_reply( const struct create_semaphore_reply *req )
1255 fprintf( stderr, " handle=%p", req->handle );
1258 static void dump_release_semaphore_request( const struct release_semaphore_request *req )
1260 fprintf( stderr, " handle=%p,", req->handle );
1261 fprintf( stderr, " count=%08x", req->count );
1264 static void dump_release_semaphore_reply( const struct release_semaphore_reply *req )
1266 fprintf( stderr, " prev_count=%08x", req->prev_count );
1269 static void dump_open_semaphore_request( const struct open_semaphore_request *req )
1271 fprintf( stderr, " access=%08x,", req->access );
1272 fprintf( stderr, " attributes=%08x,", req->attributes );
1273 fprintf( stderr, " rootdir=%p,", req->rootdir );
1274 fprintf( stderr, " name=" );
1275 dump_varargs_unicode_str( cur_size );
1278 static void dump_open_semaphore_reply( const struct open_semaphore_reply *req )
1280 fprintf( stderr, " handle=%p", req->handle );
1283 static void dump_create_file_request( const struct create_file_request *req )
1285 fprintf( stderr, " access=%08x,", req->access );
1286 fprintf( stderr, " attributes=%08x,", req->attributes );
1287 fprintf( stderr, " sharing=%08x,", req->sharing );
1288 fprintf( stderr, " create=%d,", req->create );
1289 fprintf( stderr, " options=%08x,", req->options );
1290 fprintf( stderr, " attrs=%08x,", req->attrs );
1291 fprintf( stderr, " objattr=" );
1292 dump_varargs_object_attributes( cur_size );
1293 fputc( ',', stderr );
1294 fprintf( stderr, " filename=" );
1295 dump_varargs_string( cur_size );
1298 static void dump_create_file_reply( const struct create_file_reply *req )
1300 fprintf( stderr, " handle=%p", req->handle );
1303 static void dump_open_file_object_request( const struct open_file_object_request *req )
1305 fprintf( stderr, " access=%08x,", req->access );
1306 fprintf( stderr, " attributes=%08x,", req->attributes );
1307 fprintf( stderr, " rootdir=%p,", req->rootdir );
1308 fprintf( stderr, " sharing=%08x,", req->sharing );
1309 fprintf( stderr, " options=%08x,", req->options );
1310 fprintf( stderr, " filename=" );
1311 dump_varargs_unicode_str( cur_size );
1314 static void dump_open_file_object_reply( const struct open_file_object_reply *req )
1316 fprintf( stderr, " handle=%p", req->handle );
1319 static void dump_alloc_file_handle_request( const struct alloc_file_handle_request *req )
1321 fprintf( stderr, " access=%08x,", req->access );
1322 fprintf( stderr, " attributes=%08x,", req->attributes );
1323 fprintf( stderr, " fd=%d", req->fd );
1326 static void dump_alloc_file_handle_reply( const struct alloc_file_handle_reply *req )
1328 fprintf( stderr, " handle=%p", req->handle );
1331 static void dump_get_handle_fd_request( const struct get_handle_fd_request *req )
1333 fprintf( stderr, " handle=%p", req->handle );
1336 static void dump_get_handle_fd_reply( const struct get_handle_fd_reply *req )
1338 fprintf( stderr, " type=%d,", req->type );
1339 fprintf( stderr, " removable=%d,", req->removable );
1340 fprintf( stderr, " access=%08x,", req->access );
1341 fprintf( stderr, " options=%08x", req->options );
1344 static void dump_flush_file_request( const struct flush_file_request *req )
1346 fprintf( stderr, " handle=%p", req->handle );
1349 static void dump_flush_file_reply( const struct flush_file_reply *req )
1351 fprintf( stderr, " event=%p", req->event );
1354 static void dump_lock_file_request( const struct lock_file_request *req )
1356 fprintf( stderr, " handle=%p,", req->handle );
1357 fprintf( stderr, " offset=" );
1358 dump_file_pos( &req->offset );
1359 fprintf( stderr, "," );
1360 fprintf( stderr, " count=" );
1361 dump_file_pos( &req->count );
1362 fprintf( stderr, "," );
1363 fprintf( stderr, " shared=%d,", req->shared );
1364 fprintf( stderr, " wait=%d", req->wait );
1367 static void dump_lock_file_reply( const struct lock_file_reply *req )
1369 fprintf( stderr, " handle=%p,", req->handle );
1370 fprintf( stderr, " overlapped=%d", req->overlapped );
1373 static void dump_unlock_file_request( const struct unlock_file_request *req )
1375 fprintf( stderr, " handle=%p,", req->handle );
1376 fprintf( stderr, " offset=" );
1377 dump_file_pos( &req->offset );
1378 fprintf( stderr, "," );
1379 fprintf( stderr, " count=" );
1380 dump_file_pos( &req->count );
1383 static void dump_create_socket_request( const struct create_socket_request *req )
1385 fprintf( stderr, " access=%08x,", req->access );
1386 fprintf( stderr, " attributes=%08x,", req->attributes );
1387 fprintf( stderr, " family=%d,", req->family );
1388 fprintf( stderr, " type=%d,", req->type );
1389 fprintf( stderr, " protocol=%d,", req->protocol );
1390 fprintf( stderr, " flags=%08x", req->flags );
1393 static void dump_create_socket_reply( const struct create_socket_reply *req )
1395 fprintf( stderr, " handle=%p", req->handle );
1398 static void dump_accept_socket_request( const struct accept_socket_request *req )
1400 fprintf( stderr, " lhandle=%p,", req->lhandle );
1401 fprintf( stderr, " access=%08x,", req->access );
1402 fprintf( stderr, " attributes=%08x", req->attributes );
1405 static void dump_accept_socket_reply( const struct accept_socket_reply *req )
1407 fprintf( stderr, " handle=%p", req->handle );
1410 static void dump_set_socket_event_request( const struct set_socket_event_request *req )
1412 fprintf( stderr, " handle=%p,", req->handle );
1413 fprintf( stderr, " mask=%08x,", req->mask );
1414 fprintf( stderr, " event=%p,", req->event );
1415 fprintf( stderr, " window=%p,", req->window );
1416 fprintf( stderr, " msg=%08x", req->msg );
1419 static void dump_get_socket_event_request( const struct get_socket_event_request *req )
1421 fprintf( stderr, " handle=%p,", req->handle );
1422 fprintf( stderr, " service=%d,", req->service );
1423 fprintf( stderr, " c_event=%p", req->c_event );
1426 static void dump_get_socket_event_reply( const struct get_socket_event_reply *req )
1428 fprintf( stderr, " mask=%08x,", req->mask );
1429 fprintf( stderr, " pmask=%08x,", req->pmask );
1430 fprintf( stderr, " state=%08x,", req->state );
1431 fprintf( stderr, " errors=" );
1432 dump_varargs_ints( cur_size );
1435 static void dump_enable_socket_event_request( const struct enable_socket_event_request *req )
1437 fprintf( stderr, " handle=%p,", req->handle );
1438 fprintf( stderr, " mask=%08x,", req->mask );
1439 fprintf( stderr, " sstate=%08x,", req->sstate );
1440 fprintf( stderr, " cstate=%08x", req->cstate );
1443 static void dump_set_socket_deferred_request( const struct set_socket_deferred_request *req )
1445 fprintf( stderr, " handle=%p,", req->handle );
1446 fprintf( stderr, " deferred=%p", req->deferred );
1449 static void dump_alloc_console_request( const struct alloc_console_request *req )
1451 fprintf( stderr, " access=%08x,", req->access );
1452 fprintf( stderr, " attributes=%08x,", req->attributes );
1453 fprintf( stderr, " pid=%04x", req->pid );
1456 static void dump_alloc_console_reply( const struct alloc_console_reply *req )
1458 fprintf( stderr, " handle_in=%p,", req->handle_in );
1459 fprintf( stderr, " event=%p", req->event );
1462 static void dump_free_console_request( const struct free_console_request *req )
1466 static void dump_get_console_renderer_events_request( const struct get_console_renderer_events_request *req )
1468 fprintf( stderr, " handle=%p", req->handle );
1471 static void dump_get_console_renderer_events_reply( const struct get_console_renderer_events_reply *req )
1473 fprintf( stderr, " data=" );
1474 dump_varargs_bytes( cur_size );
1477 static void dump_open_console_request( const struct open_console_request *req )
1479 fprintf( stderr, " from=%p,", req->from );
1480 fprintf( stderr, " access=%08x,", req->access );
1481 fprintf( stderr, " attributes=%08x,", req->attributes );
1482 fprintf( stderr, " share=%d", req->share );
1485 static void dump_open_console_reply( const struct open_console_reply *req )
1487 fprintf( stderr, " handle=%p", req->handle );
1490 static void dump_get_console_wait_event_request( const struct get_console_wait_event_request *req )
1494 static void dump_get_console_wait_event_reply( const struct get_console_wait_event_reply *req )
1496 fprintf( stderr, " handle=%p", req->handle );
1499 static void dump_get_console_mode_request( const struct get_console_mode_request *req )
1501 fprintf( stderr, " handle=%p", req->handle );
1504 static void dump_get_console_mode_reply( const struct get_console_mode_reply *req )
1506 fprintf( stderr, " mode=%d", req->mode );
1509 static void dump_set_console_mode_request( const struct set_console_mode_request *req )
1511 fprintf( stderr, " handle=%p,", req->handle );
1512 fprintf( stderr, " mode=%d", req->mode );
1515 static void dump_set_console_input_info_request( const struct set_console_input_info_request *req )
1517 fprintf( stderr, " handle=%p,", req->handle );
1518 fprintf( stderr, " mask=%d,", req->mask );
1519 fprintf( stderr, " active_sb=%p,", req->active_sb );
1520 fprintf( stderr, " history_mode=%d,", req->history_mode );
1521 fprintf( stderr, " history_size=%d,", req->history_size );
1522 fprintf( stderr, " edition_mode=%d,", req->edition_mode );
1523 fprintf( stderr, " input_cp=%d,", req->input_cp );
1524 fprintf( stderr, " output_cp=%d,", req->output_cp );
1525 fprintf( stderr, " win=%p,", req->win );
1526 fprintf( stderr, " title=" );
1527 dump_varargs_unicode_str( cur_size );
1530 static void dump_get_console_input_info_request( const struct get_console_input_info_request *req )
1532 fprintf( stderr, " handle=%p", req->handle );
1535 static void dump_get_console_input_info_reply( const struct get_console_input_info_reply *req )
1537 fprintf( stderr, " history_mode=%d,", req->history_mode );
1538 fprintf( stderr, " history_size=%d,", req->history_size );
1539 fprintf( stderr, " history_index=%d,", req->history_index );
1540 fprintf( stderr, " edition_mode=%d,", req->edition_mode );
1541 fprintf( stderr, " input_cp=%d,", req->input_cp );
1542 fprintf( stderr, " output_cp=%d,", req->output_cp );
1543 fprintf( stderr, " win=%p,", req->win );
1544 fprintf( stderr, " title=" );
1545 dump_varargs_unicode_str( cur_size );
1548 static void dump_append_console_input_history_request( const struct append_console_input_history_request *req )
1550 fprintf( stderr, " handle=%p,", req->handle );
1551 fprintf( stderr, " line=" );
1552 dump_varargs_unicode_str( cur_size );
1555 static void dump_get_console_input_history_request( const struct get_console_input_history_request *req )
1557 fprintf( stderr, " handle=%p,", req->handle );
1558 fprintf( stderr, " index=%d", req->index );
1561 static void dump_get_console_input_history_reply( const struct get_console_input_history_reply *req )
1563 fprintf( stderr, " total=%d,", req->total );
1564 fprintf( stderr, " line=" );
1565 dump_varargs_unicode_str( cur_size );
1568 static void dump_create_console_output_request( const struct create_console_output_request *req )
1570 fprintf( stderr, " handle_in=%p,", req->handle_in );
1571 fprintf( stderr, " access=%08x,", req->access );
1572 fprintf( stderr, " attributes=%08x,", req->attributes );
1573 fprintf( stderr, " share=%08x", req->share );
1576 static void dump_create_console_output_reply( const struct create_console_output_reply *req )
1578 fprintf( stderr, " handle_out=%p", req->handle_out );
1581 static void dump_set_console_output_info_request( const struct set_console_output_info_request *req )
1583 fprintf( stderr, " handle=%p,", req->handle );
1584 fprintf( stderr, " mask=%d,", req->mask );
1585 fprintf( stderr, " cursor_size=%d,", req->cursor_size );
1586 fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
1587 fprintf( stderr, " cursor_x=%d,", req->cursor_x );
1588 fprintf( stderr, " cursor_y=%d,", req->cursor_y );
1589 fprintf( stderr, " width=%d,", req->width );
1590 fprintf( stderr, " height=%d,", req->height );
1591 fprintf( stderr, " attr=%d,", req->attr );
1592 fprintf( stderr, " win_left=%d,", req->win_left );
1593 fprintf( stderr, " win_top=%d,", req->win_top );
1594 fprintf( stderr, " win_right=%d,", req->win_right );
1595 fprintf( stderr, " win_bottom=%d,", req->win_bottom );
1596 fprintf( stderr, " max_width=%d,", req->max_width );
1597 fprintf( stderr, " max_height=%d", req->max_height );
1600 static void dump_get_console_output_info_request( const struct get_console_output_info_request *req )
1602 fprintf( stderr, " handle=%p", req->handle );
1605 static void dump_get_console_output_info_reply( const struct get_console_output_info_reply *req )
1607 fprintf( stderr, " cursor_size=%d,", req->cursor_size );
1608 fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
1609 fprintf( stderr, " cursor_x=%d,", req->cursor_x );
1610 fprintf( stderr, " cursor_y=%d,", req->cursor_y );
1611 fprintf( stderr, " width=%d,", req->width );
1612 fprintf( stderr, " height=%d,", req->height );
1613 fprintf( stderr, " attr=%d,", req->attr );
1614 fprintf( stderr, " win_left=%d,", req->win_left );
1615 fprintf( stderr, " win_top=%d,", req->win_top );
1616 fprintf( stderr, " win_right=%d,", req->win_right );
1617 fprintf( stderr, " win_bottom=%d,", req->win_bottom );
1618 fprintf( stderr, " max_width=%d,", req->max_width );
1619 fprintf( stderr, " max_height=%d", req->max_height );
1622 static void dump_write_console_input_request( const struct write_console_input_request *req )
1624 fprintf( stderr, " handle=%p,", req->handle );
1625 fprintf( stderr, " rec=" );
1626 dump_varargs_input_records( cur_size );
1629 static void dump_write_console_input_reply( const struct write_console_input_reply *req )
1631 fprintf( stderr, " written=%d", req->written );
1634 static void dump_read_console_input_request( const struct read_console_input_request *req )
1636 fprintf( stderr, " handle=%p,", req->handle );
1637 fprintf( stderr, " flush=%d", req->flush );
1640 static void dump_read_console_input_reply( const struct read_console_input_reply *req )
1642 fprintf( stderr, " read=%d,", req->read );
1643 fprintf( stderr, " rec=" );
1644 dump_varargs_input_records( cur_size );
1647 static void dump_write_console_output_request( const struct write_console_output_request *req )
1649 fprintf( stderr, " handle=%p,", req->handle );
1650 fprintf( stderr, " x=%d,", req->x );
1651 fprintf( stderr, " y=%d,", req->y );
1652 fprintf( stderr, " mode=%d,", req->mode );
1653 fprintf( stderr, " wrap=%d,", req->wrap );
1654 fprintf( stderr, " data=" );
1655 dump_varargs_bytes( cur_size );
1658 static void dump_write_console_output_reply( const struct write_console_output_reply *req )
1660 fprintf( stderr, " written=%d,", req->written );
1661 fprintf( stderr, " width=%d,", req->width );
1662 fprintf( stderr, " height=%d", req->height );
1665 static void dump_fill_console_output_request( const struct fill_console_output_request *req )
1667 fprintf( stderr, " handle=%p,", req->handle );
1668 fprintf( stderr, " x=%d,", req->x );
1669 fprintf( stderr, " y=%d,", req->y );
1670 fprintf( stderr, " mode=%d,", req->mode );
1671 fprintf( stderr, " count=%d,", req->count );
1672 fprintf( stderr, " wrap=%d,", req->wrap );
1673 fprintf( stderr, " data=" );
1674 dump_char_info( &req->data );
1677 static void dump_fill_console_output_reply( const struct fill_console_output_reply *req )
1679 fprintf( stderr, " written=%d", req->written );
1682 static void dump_read_console_output_request( const struct read_console_output_request *req )
1684 fprintf( stderr, " handle=%p,", req->handle );
1685 fprintf( stderr, " x=%d,", req->x );
1686 fprintf( stderr, " y=%d,", req->y );
1687 fprintf( stderr, " mode=%d,", req->mode );
1688 fprintf( stderr, " wrap=%d", req->wrap );
1691 static void dump_read_console_output_reply( const struct read_console_output_reply *req )
1693 fprintf( stderr, " width=%d,", req->width );
1694 fprintf( stderr, " height=%d,", req->height );
1695 fprintf( stderr, " data=" );
1696 dump_varargs_bytes( cur_size );
1699 static void dump_move_console_output_request( const struct move_console_output_request *req )
1701 fprintf( stderr, " handle=%p,", req->handle );
1702 fprintf( stderr, " x_src=%d,", req->x_src );
1703 fprintf( stderr, " y_src=%d,", req->y_src );
1704 fprintf( stderr, " x_dst=%d,", req->x_dst );
1705 fprintf( stderr, " y_dst=%d,", req->y_dst );
1706 fprintf( stderr, " w=%d,", req->w );
1707 fprintf( stderr, " h=%d", req->h );
1710 static void dump_send_console_signal_request( const struct send_console_signal_request *req )
1712 fprintf( stderr, " signal=%d,", req->signal );
1713 fprintf( stderr, " group_id=%04x", req->group_id );
1716 static void dump_read_directory_changes_request( const struct read_directory_changes_request *req )
1718 fprintf( stderr, " filter=%08x,", req->filter );
1719 fprintf( stderr, " handle=%p,", req->handle );
1720 fprintf( stderr, " subtree=%d,", req->subtree );
1721 fprintf( stderr, " want_data=%d,", req->want_data );
1722 fprintf( stderr, " async=" );
1723 dump_async_data( &req->async );
1726 static void dump_read_change_request( const struct read_change_request *req )
1728 fprintf( stderr, " handle=%p", req->handle );
1731 static void dump_read_change_reply( const struct read_change_reply *req )
1733 fprintf( stderr, " action=%d,", req->action );
1734 fprintf( stderr, " name=" );
1735 dump_varargs_string( cur_size );
1738 static void dump_create_mapping_request( const struct create_mapping_request *req )
1740 fprintf( stderr, " access=%08x,", req->access );
1741 fprintf( stderr, " attributes=%08x,", req->attributes );
1742 fprintf( stderr, " size=" );
1743 dump_file_pos( &req->size );
1744 fprintf( stderr, "," );
1745 fprintf( stderr, " protect=%08x,", req->protect );
1746 fprintf( stderr, " file_handle=%p,", req->file_handle );
1747 fprintf( stderr, " objattr=" );
1748 dump_varargs_object_attributes( cur_size );
1751 static void dump_create_mapping_reply( const struct create_mapping_reply *req )
1753 fprintf( stderr, " handle=%p", req->handle );
1756 static void dump_open_mapping_request( const struct open_mapping_request *req )
1758 fprintf( stderr, " access=%08x,", req->access );
1759 fprintf( stderr, " attributes=%08x,", req->attributes );
1760 fprintf( stderr, " rootdir=%p,", req->rootdir );
1761 fprintf( stderr, " name=" );
1762 dump_varargs_unicode_str( cur_size );
1765 static void dump_open_mapping_reply( const struct open_mapping_reply *req )
1767 fprintf( stderr, " handle=%p", req->handle );
1770 static void dump_get_mapping_info_request( const struct get_mapping_info_request *req )
1772 fprintf( stderr, " handle=%p,", req->handle );
1773 fprintf( stderr, " access=%08x", req->access );
1776 static void dump_get_mapping_info_reply( const struct get_mapping_info_reply *req )
1778 fprintf( stderr, " size=" );
1779 dump_file_pos( &req->size );
1780 fprintf( stderr, "," );
1781 fprintf( stderr, " protect=%d,", req->protect );
1782 fprintf( stderr, " header_size=%d,", req->header_size );
1783 fprintf( stderr, " base=%p,", req->base );
1784 fprintf( stderr, " mapping=%p,", req->mapping );
1785 fprintf( stderr, " shared_file=%p", req->shared_file );
1788 static void dump_get_mapping_committed_range_request( const struct get_mapping_committed_range_request *req )
1790 fprintf( stderr, " handle=%p,", req->handle );
1791 fprintf( stderr, " offset=" );
1792 dump_file_pos( &req->offset );
1795 static void dump_get_mapping_committed_range_reply( const struct get_mapping_committed_range_reply *req )
1797 fprintf( stderr, " size=" );
1798 dump_file_pos( &req->size );
1799 fprintf( stderr, "," );
1800 fprintf( stderr, " committed=%d", req->committed );
1803 static void dump_add_mapping_committed_range_request( const struct add_mapping_committed_range_request *req )
1805 fprintf( stderr, " handle=%p,", req->handle );
1806 fprintf( stderr, " offset=" );
1807 dump_file_pos( &req->offset );
1808 fprintf( stderr, "," );
1809 fprintf( stderr, " size=" );
1810 dump_file_pos( &req->size );
1813 static void dump_create_snapshot_request( const struct create_snapshot_request *req )
1815 fprintf( stderr, " attributes=%08x,", req->attributes );
1816 fprintf( stderr, " flags=%d,", req->flags );
1817 fprintf( stderr, " pid=%04x", req->pid );
1820 static void dump_create_snapshot_reply( const struct create_snapshot_reply *req )
1822 fprintf( stderr, " handle=%p", req->handle );
1825 static void dump_next_process_request( const struct next_process_request *req )
1827 fprintf( stderr, " handle=%p,", req->handle );
1828 fprintf( stderr, " reset=%d", req->reset );
1831 static void dump_next_process_reply( const struct next_process_reply *req )
1833 fprintf( stderr, " count=%d,", req->count );
1834 fprintf( stderr, " pid=%04x,", req->pid );
1835 fprintf( stderr, " ppid=%04x,", req->ppid );
1836 fprintf( stderr, " heap=%p,", req->heap );
1837 fprintf( stderr, " module=%p,", req->module );
1838 fprintf( stderr, " threads=%d,", req->threads );
1839 fprintf( stderr, " priority=%d,", req->priority );
1840 fprintf( stderr, " handles=%d,", req->handles );
1841 fprintf( stderr, " filename=" );
1842 dump_varargs_unicode_str( cur_size );
1845 static void dump_next_thread_request( const struct next_thread_request *req )
1847 fprintf( stderr, " handle=%p,", req->handle );
1848 fprintf( stderr, " reset=%d", req->reset );
1851 static void dump_next_thread_reply( const struct next_thread_reply *req )
1853 fprintf( stderr, " count=%d,", req->count );
1854 fprintf( stderr, " pid=%04x,", req->pid );
1855 fprintf( stderr, " tid=%04x,", req->tid );
1856 fprintf( stderr, " base_pri=%d,", req->base_pri );
1857 fprintf( stderr, " delta_pri=%d", req->delta_pri );
1860 static void dump_next_module_request( const struct next_module_request *req )
1862 fprintf( stderr, " handle=%p,", req->handle );
1863 fprintf( stderr, " reset=%d", req->reset );
1866 static void dump_next_module_reply( const struct next_module_reply *req )
1868 fprintf( stderr, " pid=%04x,", req->pid );
1869 fprintf( stderr, " base=%p,", req->base );
1870 fprintf( stderr, " size=%lu,", (unsigned long)req->size );
1871 fprintf( stderr, " filename=" );
1872 dump_varargs_unicode_str( cur_size );
1875 static void dump_wait_debug_event_request( const struct wait_debug_event_request *req )
1877 fprintf( stderr, " get_handle=%d", req->get_handle );
1880 static void dump_wait_debug_event_reply( const struct wait_debug_event_reply *req )
1882 fprintf( stderr, " pid=%04x,", req->pid );
1883 fprintf( stderr, " tid=%04x,", req->tid );
1884 fprintf( stderr, " wait=%p,", req->wait );
1885 fprintf( stderr, " event=" );
1886 dump_varargs_debug_event( cur_size );
1889 static void dump_queue_exception_event_request( const struct queue_exception_event_request *req )
1891 fprintf( stderr, " first=%d,", req->first );
1892 fprintf( stderr, " record=" );
1893 dump_varargs_exc_event( cur_size );
1896 static void dump_queue_exception_event_reply( const struct queue_exception_event_reply *req )
1898 fprintf( stderr, " handle=%p", req->handle );
1901 static void dump_get_exception_status_request( const struct get_exception_status_request *req )
1903 fprintf( stderr, " handle=%p", req->handle );
1906 static void dump_get_exception_status_reply( const struct get_exception_status_reply *req )
1908 fprintf( stderr, " context=" );
1909 dump_varargs_context( cur_size );
1912 static void dump_output_debug_string_request( const struct output_debug_string_request *req )
1914 fprintf( stderr, " string=%p,", req->string );
1915 fprintf( stderr, " unicode=%d,", req->unicode );
1916 fprintf( stderr, " length=%d", req->length );
1919 static void dump_continue_debug_event_request( const struct continue_debug_event_request *req )
1921 fprintf( stderr, " pid=%04x,", req->pid );
1922 fprintf( stderr, " tid=%04x,", req->tid );
1923 fprintf( stderr, " status=%d", req->status );
1926 static void dump_debug_process_request( const struct debug_process_request *req )
1928 fprintf( stderr, " pid=%04x,", req->pid );
1929 fprintf( stderr, " attach=%d", req->attach );
1932 static void dump_debug_break_request( const struct debug_break_request *req )
1934 fprintf( stderr, " handle=%p", req->handle );
1937 static void dump_debug_break_reply( const struct debug_break_reply *req )
1939 fprintf( stderr, " self=%d", req->self );
1942 static void dump_set_debugger_kill_on_exit_request( const struct set_debugger_kill_on_exit_request *req )
1944 fprintf( stderr, " kill_on_exit=%d", req->kill_on_exit );
1947 static void dump_read_process_memory_request( const struct read_process_memory_request *req )
1949 fprintf( stderr, " handle=%p,", req->handle );
1950 fprintf( stderr, " addr=%p", req->addr );
1953 static void dump_read_process_memory_reply( const struct read_process_memory_reply *req )
1955 fprintf( stderr, " data=" );
1956 dump_varargs_bytes( cur_size );
1959 static void dump_write_process_memory_request( const struct write_process_memory_request *req )
1961 fprintf( stderr, " handle=%p,", req->handle );
1962 fprintf( stderr, " addr=%p,", req->addr );
1963 fprintf( stderr, " data=" );
1964 dump_varargs_bytes( cur_size );
1967 static void dump_create_key_request( const struct create_key_request *req )
1969 fprintf( stderr, " parent=%p,", req->parent );
1970 fprintf( stderr, " access=%08x,", req->access );
1971 fprintf( stderr, " attributes=%08x,", req->attributes );
1972 fprintf( stderr, " options=%08x,", req->options );
1973 fprintf( stderr, " modif=%ld,", (long)req->modif );
1974 fprintf( stderr, " namelen=%u,", req->namelen );
1975 fprintf( stderr, " name=" );
1976 dump_varargs_unicode_str( min(cur_size,req->namelen) );
1977 fputc( ',', stderr );
1978 fprintf( stderr, " class=" );
1979 dump_varargs_unicode_str( cur_size );
1982 static void dump_create_key_reply( const struct create_key_reply *req )
1984 fprintf( stderr, " hkey=%p,", req->hkey );
1985 fprintf( stderr, " created=%d", req->created );
1988 static void dump_open_key_request( const struct open_key_request *req )
1990 fprintf( stderr, " parent=%p,", req->parent );
1991 fprintf( stderr, " access=%08x,", req->access );
1992 fprintf( stderr, " attributes=%08x,", req->attributes );
1993 fprintf( stderr, " name=" );
1994 dump_varargs_unicode_str( cur_size );
1997 static void dump_open_key_reply( const struct open_key_reply *req )
1999 fprintf( stderr, " hkey=%p", req->hkey );
2002 static void dump_delete_key_request( const struct delete_key_request *req )
2004 fprintf( stderr, " hkey=%p", req->hkey );
2007 static void dump_flush_key_request( const struct flush_key_request *req )
2009 fprintf( stderr, " hkey=%p", req->hkey );
2012 static void dump_enum_key_request( const struct enum_key_request *req )
2014 fprintf( stderr, " hkey=%p,", req->hkey );
2015 fprintf( stderr, " index=%d,", req->index );
2016 fprintf( stderr, " info_class=%d", req->info_class );
2019 static void dump_enum_key_reply( const struct enum_key_reply *req )
2021 fprintf( stderr, " subkeys=%d,", req->subkeys );
2022 fprintf( stderr, " max_subkey=%d,", req->max_subkey );
2023 fprintf( stderr, " max_class=%d,", req->max_class );
2024 fprintf( stderr, " values=%d,", req->values );
2025 fprintf( stderr, " max_value=%d,", req->max_value );
2026 fprintf( stderr, " max_data=%d,", req->max_data );
2027 fprintf( stderr, " modif=%ld,", (long)req->modif );
2028 fprintf( stderr, " total=%u,", req->total );
2029 fprintf( stderr, " namelen=%u,", req->namelen );
2030 fprintf( stderr, " name=" );
2031 dump_varargs_unicode_str( min(cur_size,req->namelen) );
2032 fputc( ',', stderr );
2033 fprintf( stderr, " class=" );
2034 dump_varargs_unicode_str( cur_size );
2037 static void dump_set_key_value_request( const struct set_key_value_request *req )
2039 fprintf( stderr, " hkey=%p,", req->hkey );
2040 fprintf( stderr, " type=%d,", req->type );
2041 fprintf( stderr, " namelen=%u,", req->namelen );
2042 fprintf( stderr, " name=" );
2043 dump_varargs_unicode_str( min(cur_size,req->namelen) );
2044 fputc( ',', stderr );
2045 fprintf( stderr, " data=" );
2046 dump_varargs_bytes( cur_size );
2049 static void dump_get_key_value_request( const struct get_key_value_request *req )
2051 fprintf( stderr, " hkey=%p,", req->hkey );
2052 fprintf( stderr, " name=" );
2053 dump_varargs_unicode_str( cur_size );
2056 static void dump_get_key_value_reply( const struct get_key_value_reply *req )
2058 fprintf( stderr, " type=%d,", req->type );
2059 fprintf( stderr, " total=%u,", req->total );
2060 fprintf( stderr, " data=" );
2061 dump_varargs_bytes( cur_size );
2064 static void dump_enum_key_value_request( const struct enum_key_value_request *req )
2066 fprintf( stderr, " hkey=%p,", req->hkey );
2067 fprintf( stderr, " index=%d,", req->index );
2068 fprintf( stderr, " info_class=%d", req->info_class );
2071 static void dump_enum_key_value_reply( const struct enum_key_value_reply *req )
2073 fprintf( stderr, " type=%d,", req->type );
2074 fprintf( stderr, " total=%u,", req->total );
2075 fprintf( stderr, " namelen=%u,", req->namelen );
2076 fprintf( stderr, " name=" );
2077 dump_varargs_unicode_str( min(cur_size,req->namelen) );
2078 fputc( ',', stderr );
2079 fprintf( stderr, " data=" );
2080 dump_varargs_bytes( cur_size );
2083 static void dump_delete_key_value_request( const struct delete_key_value_request *req )
2085 fprintf( stderr, " hkey=%p,", req->hkey );
2086 fprintf( stderr, " name=" );
2087 dump_varargs_unicode_str( cur_size );
2090 static void dump_load_registry_request( const struct load_registry_request *req )
2092 fprintf( stderr, " hkey=%p,", req->hkey );
2093 fprintf( stderr, " file=%p,", req->file );
2094 fprintf( stderr, " name=" );
2095 dump_varargs_unicode_str( cur_size );
2098 static void dump_unload_registry_request( const struct unload_registry_request *req )
2100 fprintf( stderr, " hkey=%p", req->hkey );
2103 static void dump_save_registry_request( const struct save_registry_request *req )
2105 fprintf( stderr, " hkey=%p,", req->hkey );
2106 fprintf( stderr, " file=%p", req->file );
2109 static void dump_set_registry_notification_request( const struct set_registry_notification_request *req )
2111 fprintf( stderr, " hkey=%p,", req->hkey );
2112 fprintf( stderr, " event=%p,", req->event );
2113 fprintf( stderr, " subtree=%d,", req->subtree );
2114 fprintf( stderr, " filter=%08x", req->filter );
2117 static void dump_create_timer_request( const struct create_timer_request *req )
2119 fprintf( stderr, " access=%08x,", req->access );
2120 fprintf( stderr, " attributes=%08x,", req->attributes );
2121 fprintf( stderr, " rootdir=%p,", req->rootdir );
2122 fprintf( stderr, " manual=%d,", req->manual );
2123 fprintf( stderr, " name=" );
2124 dump_varargs_unicode_str( cur_size );
2127 static void dump_create_timer_reply( const struct create_timer_reply *req )
2129 fprintf( stderr, " handle=%p", req->handle );
2132 static void dump_open_timer_request( const struct open_timer_request *req )
2134 fprintf( stderr, " access=%08x,", req->access );
2135 fprintf( stderr, " attributes=%08x,", req->attributes );
2136 fprintf( stderr, " rootdir=%p,", req->rootdir );
2137 fprintf( stderr, " name=" );
2138 dump_varargs_unicode_str( cur_size );
2141 static void dump_open_timer_reply( const struct open_timer_reply *req )
2143 fprintf( stderr, " handle=%p", req->handle );
2146 static void dump_set_timer_request( const struct set_timer_request *req )
2148 fprintf( stderr, " handle=%p,", req->handle );
2149 fprintf( stderr, " expire=" );
2150 dump_timeout( &req->expire );
2151 fprintf( stderr, "," );
2152 fprintf( stderr, " period=%d,", req->period );
2153 fprintf( stderr, " callback=%p,", req->callback );
2154 fprintf( stderr, " arg=%p", req->arg );
2157 static void dump_set_timer_reply( const struct set_timer_reply *req )
2159 fprintf( stderr, " signaled=%d", req->signaled );
2162 static void dump_cancel_timer_request( const struct cancel_timer_request *req )
2164 fprintf( stderr, " handle=%p", req->handle );
2167 static void dump_cancel_timer_reply( const struct cancel_timer_reply *req )
2169 fprintf( stderr, " signaled=%d", req->signaled );
2172 static void dump_get_timer_info_request( const struct get_timer_info_request *req )
2174 fprintf( stderr, " handle=%p", req->handle );
2177 static void dump_get_timer_info_reply( const struct get_timer_info_reply *req )
2179 fprintf( stderr, " when=" );
2180 dump_timeout( &req->when );
2181 fprintf( stderr, "," );
2182 fprintf( stderr, " signaled=%d", req->signaled );
2185 static void dump_get_thread_context_request( const struct get_thread_context_request *req )
2187 fprintf( stderr, " handle=%p,", req->handle );
2188 fprintf( stderr, " flags=%08x,", req->flags );
2189 fprintf( stderr, " suspend=%d", req->suspend );
2192 static void dump_get_thread_context_reply( const struct get_thread_context_reply *req )
2194 fprintf( stderr, " self=%d,", req->self );
2195 fprintf( stderr, " context=" );
2196 dump_varargs_context( cur_size );
2199 static void dump_set_thread_context_request( const struct set_thread_context_request *req )
2201 fprintf( stderr, " handle=%p,", req->handle );
2202 fprintf( stderr, " flags=%08x,", req->flags );
2203 fprintf( stderr, " suspend=%d,", req->suspend );
2204 fprintf( stderr, " context=" );
2205 dump_varargs_context( cur_size );
2208 static void dump_set_thread_context_reply( const struct set_thread_context_reply *req )
2210 fprintf( stderr, " self=%d", req->self );
2213 static void dump_get_selector_entry_request( const struct get_selector_entry_request *req )
2215 fprintf( stderr, " handle=%p,", req->handle );
2216 fprintf( stderr, " entry=%d", req->entry );
2219 static void dump_get_selector_entry_reply( const struct get_selector_entry_reply *req )
2221 fprintf( stderr, " base=%08x,", req->base );
2222 fprintf( stderr, " limit=%08x,", req->limit );
2223 fprintf( stderr, " flags=%02x", req->flags );
2226 static void dump_add_atom_request( const struct add_atom_request *req )
2228 fprintf( stderr, " table=%p,", req->table );
2229 fprintf( stderr, " name=" );
2230 dump_varargs_unicode_str( cur_size );
2233 static void dump_add_atom_reply( const struct add_atom_reply *req )
2235 fprintf( stderr, " atom=%04x", req->atom );
2238 static void dump_delete_atom_request( const struct delete_atom_request *req )
2240 fprintf( stderr, " table=%p,", req->table );
2241 fprintf( stderr, " atom=%04x", req->atom );
2244 static void dump_find_atom_request( const struct find_atom_request *req )
2246 fprintf( stderr, " table=%p,", req->table );
2247 fprintf( stderr, " name=" );
2248 dump_varargs_unicode_str( cur_size );
2251 static void dump_find_atom_reply( const struct find_atom_reply *req )
2253 fprintf( stderr, " atom=%04x", req->atom );
2256 static void dump_get_atom_information_request( const struct get_atom_information_request *req )
2258 fprintf( stderr, " table=%p,", req->table );
2259 fprintf( stderr, " atom=%04x", req->atom );
2262 static void dump_get_atom_information_reply( const struct get_atom_information_reply *req )
2264 fprintf( stderr, " count=%d,", req->count );
2265 fprintf( stderr, " pinned=%d,", req->pinned );
2266 fprintf( stderr, " total=%u,", req->total );
2267 fprintf( stderr, " name=" );
2268 dump_varargs_unicode_str( cur_size );
2271 static void dump_set_atom_information_request( const struct set_atom_information_request *req )
2273 fprintf( stderr, " table=%p,", req->table );
2274 fprintf( stderr, " atom=%04x,", req->atom );
2275 fprintf( stderr, " pinned=%d", req->pinned );
2278 static void dump_empty_atom_table_request( const struct empty_atom_table_request *req )
2280 fprintf( stderr, " table=%p,", req->table );
2281 fprintf( stderr, " if_pinned=%d", req->if_pinned );
2284 static void dump_init_atom_table_request( const struct init_atom_table_request *req )
2286 fprintf( stderr, " entries=%d", req->entries );
2289 static void dump_init_atom_table_reply( const struct init_atom_table_reply *req )
2291 fprintf( stderr, " table=%p", req->table );
2294 static void dump_get_msg_queue_request( const struct get_msg_queue_request *req )
2298 static void dump_get_msg_queue_reply( const struct get_msg_queue_reply *req )
2300 fprintf( stderr, " handle=%p", req->handle );
2303 static void dump_set_queue_fd_request( const struct set_queue_fd_request *req )
2305 fprintf( stderr, " handle=%p", req->handle );
2308 static void dump_set_queue_mask_request( const struct set_queue_mask_request *req )
2310 fprintf( stderr, " wake_mask=%08x,", req->wake_mask );
2311 fprintf( stderr, " changed_mask=%08x,", req->changed_mask );
2312 fprintf( stderr, " skip_wait=%d", req->skip_wait );
2315 static void dump_set_queue_mask_reply( const struct set_queue_mask_reply *req )
2317 fprintf( stderr, " wake_bits=%08x,", req->wake_bits );
2318 fprintf( stderr, " changed_bits=%08x", req->changed_bits );
2321 static void dump_get_queue_status_request( const struct get_queue_status_request *req )
2323 fprintf( stderr, " clear=%d", req->clear );
2326 static void dump_get_queue_status_reply( const struct get_queue_status_reply *req )
2328 fprintf( stderr, " wake_bits=%08x,", req->wake_bits );
2329 fprintf( stderr, " changed_bits=%08x", req->changed_bits );
2332 static void dump_get_process_idle_event_request( const struct get_process_idle_event_request *req )
2334 fprintf( stderr, " handle=%p", req->handle );
2337 static void dump_get_process_idle_event_reply( const struct get_process_idle_event_reply *req )
2339 fprintf( stderr, " event=%p", req->event );
2342 static void dump_send_message_request( const struct send_message_request *req )
2344 fprintf( stderr, " id=%04x,", req->id );
2345 fprintf( stderr, " type=%d,", req->type );
2346 fprintf( stderr, " flags=%d,", req->flags );
2347 fprintf( stderr, " win=%p,", req->win );
2348 fprintf( stderr, " msg=%08x,", req->msg );
2349 fprintf( stderr, " wparam=%lx,", req->wparam );
2350 fprintf( stderr, " lparam=%lx,", req->lparam );
2351 fprintf( stderr, " timeout=" );
2352 dump_timeout( &req->timeout );
2353 fprintf( stderr, "," );
2354 fprintf( stderr, " data=" );
2355 dump_varargs_message_data( cur_size );
2358 static void dump_post_quit_message_request( const struct post_quit_message_request *req )
2360 fprintf( stderr, " exit_code=%d", req->exit_code );
2363 static void dump_send_hardware_message_request( const struct send_hardware_message_request *req )
2365 fprintf( stderr, " id=%04x,", req->id );
2366 fprintf( stderr, " win=%p,", req->win );
2367 fprintf( stderr, " msg=%08x,", req->msg );
2368 fprintf( stderr, " time=%08x,", req->time );
2369 fprintf( stderr, " wparam=%lx,", req->wparam );
2370 fprintf( stderr, " lparam=%lx,", req->lparam );
2371 fprintf( stderr, " info=%lx,", req->info );
2372 fprintf( stderr, " x=%d,", req->x );
2373 fprintf( stderr, " y=%d", req->y );
2376 static void dump_get_message_request( const struct get_message_request *req )
2378 fprintf( stderr, " flags=%08x,", req->flags );
2379 fprintf( stderr, " get_win=%p,", req->get_win );
2380 fprintf( stderr, " get_first=%08x,", req->get_first );
2381 fprintf( stderr, " get_last=%08x,", req->get_last );
2382 fprintf( stderr, " hw_id=%08x,", req->hw_id );
2383 fprintf( stderr, " wake_mask=%08x,", req->wake_mask );
2384 fprintf( stderr, " changed_mask=%08x", req->changed_mask );
2387 static void dump_get_message_reply( const struct get_message_reply *req )
2389 fprintf( stderr, " win=%p,", req->win );
2390 fprintf( stderr, " type=%d,", req->type );
2391 fprintf( stderr, " msg=%08x,", req->msg );
2392 fprintf( stderr, " wparam=%lx,", req->wparam );
2393 fprintf( stderr, " lparam=%lx,", req->lparam );
2394 fprintf( stderr, " info=%lx,", req->info );
2395 fprintf( stderr, " x=%d,", req->x );
2396 fprintf( stderr, " y=%d,", req->y );
2397 fprintf( stderr, " time=%08x,", req->time );
2398 fprintf( stderr, " hw_id=%08x,", req->hw_id );
2399 fprintf( stderr, " active_hooks=%08x,", req->active_hooks );
2400 fprintf( stderr, " total=%u,", req->total );
2401 fprintf( stderr, " data=" );
2402 dump_varargs_message_data( cur_size );
2405 static void dump_reply_message_request( const struct reply_message_request *req )
2407 fprintf( stderr, " result=%lx,", req->result );
2408 fprintf( stderr, " remove=%d,", req->remove );
2409 fprintf( stderr, " data=" );
2410 dump_varargs_bytes( cur_size );
2413 static void dump_accept_hardware_message_request( const struct accept_hardware_message_request *req )
2415 fprintf( stderr, " hw_id=%08x,", req->hw_id );
2416 fprintf( stderr, " remove=%d,", req->remove );
2417 fprintf( stderr, " new_win=%p", req->new_win );
2420 static void dump_get_message_reply_request( const struct get_message_reply_request *req )
2422 fprintf( stderr, " cancel=%d", req->cancel );
2425 static void dump_get_message_reply_reply( const struct get_message_reply_reply *req )
2427 fprintf( stderr, " result=%lx,", req->result );
2428 fprintf( stderr, " data=" );
2429 dump_varargs_bytes( cur_size );
2432 static void dump_set_win_timer_request( const struct set_win_timer_request *req )
2434 fprintf( stderr, " win=%p,", req->win );
2435 fprintf( stderr, " msg=%08x,", req->msg );
2436 fprintf( stderr, " rate=%08x,", req->rate );
2437 fprintf( stderr, " id=%lx,", req->id );
2438 fprintf( stderr, " lparam=%lx", req->lparam );
2441 static void dump_set_win_timer_reply( const struct set_win_timer_reply *req )
2443 fprintf( stderr, " id=%lx", req->id );
2446 static void dump_kill_win_timer_request( const struct kill_win_timer_request *req )
2448 fprintf( stderr, " win=%p,", req->win );
2449 fprintf( stderr, " msg=%08x,", req->msg );
2450 fprintf( stderr, " id=%lx", req->id );
2453 static void dump_is_window_hung_request( const struct is_window_hung_request *req )
2455 fprintf( stderr, " win=%p", req->win );
2458 static void dump_is_window_hung_reply( const struct is_window_hung_reply *req )
2460 fprintf( stderr, " is_hung=%d", req->is_hung );
2463 static void dump_get_serial_info_request( const struct get_serial_info_request *req )
2465 fprintf( stderr, " handle=%p", req->handle );
2468 static void dump_get_serial_info_reply( const struct get_serial_info_reply *req )
2470 fprintf( stderr, " readinterval=%08x,", req->readinterval );
2471 fprintf( stderr, " readconst=%08x,", req->readconst );
2472 fprintf( stderr, " readmult=%08x,", req->readmult );
2473 fprintf( stderr, " writeconst=%08x,", req->writeconst );
2474 fprintf( stderr, " writemult=%08x,", req->writemult );
2475 fprintf( stderr, " eventmask=%08x", req->eventmask );
2478 static void dump_set_serial_info_request( const struct set_serial_info_request *req )
2480 fprintf( stderr, " handle=%p,", req->handle );
2481 fprintf( stderr, " flags=%d,", req->flags );
2482 fprintf( stderr, " readinterval=%08x,", req->readinterval );
2483 fprintf( stderr, " readconst=%08x,", req->readconst );
2484 fprintf( stderr, " readmult=%08x,", req->readmult );
2485 fprintf( stderr, " writeconst=%08x,", req->writeconst );
2486 fprintf( stderr, " writemult=%08x,", req->writemult );
2487 fprintf( stderr, " eventmask=%08x", req->eventmask );
2490 static void dump_register_async_request( const struct register_async_request *req )
2492 fprintf( stderr, " handle=%p,", req->handle );
2493 fprintf( stderr, " type=%d,", req->type );
2494 fprintf( stderr, " count=%d,", req->count );
2495 fprintf( stderr, " async=" );
2496 dump_async_data( &req->async );
2499 static void dump_cancel_async_request( const struct cancel_async_request *req )
2501 fprintf( stderr, " handle=%p", req->handle );
2504 static void dump_ioctl_request( const struct ioctl_request *req )
2506 fprintf( stderr, " handle=%p,", req->handle );
2507 fprintf( stderr, " code=" );
2508 dump_ioctl_code( &req->code );
2509 fprintf( stderr, "," );
2510 fprintf( stderr, " async=" );
2511 dump_async_data( &req->async );
2512 fprintf( stderr, "," );
2513 fprintf( stderr, " in_data=" );
2514 dump_varargs_bytes( cur_size );
2517 static void dump_ioctl_reply( const struct ioctl_reply *req )
2519 fprintf( stderr, " wait=%p,", req->wait );
2520 fprintf( stderr, " options=%08x,", req->options );
2521 fprintf( stderr, " out_data=" );
2522 dump_varargs_bytes( cur_size );
2525 static void dump_get_ioctl_result_request( const struct get_ioctl_result_request *req )
2527 fprintf( stderr, " handle=%p,", req->handle );
2528 fprintf( stderr, " user_arg=%p", req->user_arg );
2531 static void dump_get_ioctl_result_reply( const struct get_ioctl_result_reply *req )
2533 fprintf( stderr, " out_data=" );
2534 dump_varargs_bytes( cur_size );
2537 static void dump_create_named_pipe_request( const struct create_named_pipe_request *req )
2539 fprintf( stderr, " access=%08x,", req->access );
2540 fprintf( stderr, " attributes=%08x,", req->attributes );
2541 fprintf( stderr, " rootdir=%p,", req->rootdir );
2542 fprintf( stderr, " options=%08x,", req->options );
2543 fprintf( stderr, " flags=%08x,", req->flags );
2544 fprintf( stderr, " maxinstances=%08x,", req->maxinstances );
2545 fprintf( stderr, " outsize=%08x,", req->outsize );
2546 fprintf( stderr, " insize=%08x,", req->insize );
2547 fprintf( stderr, " timeout=" );
2548 dump_timeout( &req->timeout );
2549 fprintf( stderr, "," );
2550 fprintf( stderr, " name=" );
2551 dump_varargs_unicode_str( cur_size );
2554 static void dump_create_named_pipe_reply( const struct create_named_pipe_reply *req )
2556 fprintf( stderr, " handle=%p", req->handle );
2559 static void dump_get_named_pipe_info_request( const struct get_named_pipe_info_request *req )
2561 fprintf( stderr, " handle=%p", req->handle );
2564 static void dump_get_named_pipe_info_reply( const struct get_named_pipe_info_reply *req )
2566 fprintf( stderr, " flags=%08x,", req->flags );
2567 fprintf( stderr, " maxinstances=%08x,", req->maxinstances );
2568 fprintf( stderr, " instances=%08x,", req->instances );
2569 fprintf( stderr, " outsize=%08x,", req->outsize );
2570 fprintf( stderr, " insize=%08x", req->insize );
2573 static void dump_create_window_request( const struct create_window_request *req )
2575 fprintf( stderr, " parent=%p,", req->parent );
2576 fprintf( stderr, " owner=%p,", req->owner );
2577 fprintf( stderr, " atom=%04x,", req->atom );
2578 fprintf( stderr, " instance=%p,", req->instance );
2579 fprintf( stderr, " class=" );
2580 dump_varargs_unicode_str( cur_size );
2583 static void dump_create_window_reply( const struct create_window_reply *req )
2585 fprintf( stderr, " handle=%p,", req->handle );
2586 fprintf( stderr, " parent=%p,", req->parent );
2587 fprintf( stderr, " owner=%p,", req->owner );
2588 fprintf( stderr, " extra=%d,", req->extra );
2589 fprintf( stderr, " class_ptr=%p", req->class_ptr );
2592 static void dump_destroy_window_request( const struct destroy_window_request *req )
2594 fprintf( stderr, " handle=%p", req->handle );
2597 static void dump_get_desktop_window_request( const struct get_desktop_window_request *req )
2599 fprintf( stderr, " force=%d", req->force );
2602 static void dump_get_desktop_window_reply( const struct get_desktop_window_reply *req )
2604 fprintf( stderr, " top_window=%p,", req->top_window );
2605 fprintf( stderr, " msg_window=%p", req->msg_window );
2608 static void dump_set_window_owner_request( const struct set_window_owner_request *req )
2610 fprintf( stderr, " handle=%p,", req->handle );
2611 fprintf( stderr, " owner=%p", req->owner );
2614 static void dump_set_window_owner_reply( const struct set_window_owner_reply *req )
2616 fprintf( stderr, " full_owner=%p,", req->full_owner );
2617 fprintf( stderr, " prev_owner=%p", req->prev_owner );
2620 static void dump_get_window_info_request( const struct get_window_info_request *req )
2622 fprintf( stderr, " handle=%p", req->handle );
2625 static void dump_get_window_info_reply( const struct get_window_info_reply *req )
2627 fprintf( stderr, " full_handle=%p,", req->full_handle );
2628 fprintf( stderr, " last_active=%p,", req->last_active );
2629 fprintf( stderr, " pid=%04x,", req->pid );
2630 fprintf( stderr, " tid=%04x,", req->tid );
2631 fprintf( stderr, " atom=%04x,", req->atom );
2632 fprintf( stderr, " is_unicode=%d", req->is_unicode );
2635 static void dump_set_window_info_request( const struct set_window_info_request *req )
2637 fprintf( stderr, " flags=%08x,", req->flags );
2638 fprintf( stderr, " handle=%p,", req->handle );
2639 fprintf( stderr, " style=%08x,", req->style );
2640 fprintf( stderr, " ex_style=%08x,", req->ex_style );
2641 fprintf( stderr, " id=%08x,", req->id );
2642 fprintf( stderr, " is_unicode=%d,", req->is_unicode );
2643 fprintf( stderr, " instance=%p,", req->instance );
2644 fprintf( stderr, " user_data=%lx,", req->user_data );
2645 fprintf( stderr, " extra_offset=%d,", req->extra_offset );
2646 fprintf( stderr, " extra_size=%u,", req->extra_size );
2647 fprintf( stderr, " extra_value=%lx", req->extra_value );
2650 static void dump_set_window_info_reply( const struct set_window_info_reply *req )
2652 fprintf( stderr, " old_style=%08x,", req->old_style );
2653 fprintf( stderr, " old_ex_style=%08x,", req->old_ex_style );
2654 fprintf( stderr, " old_id=%08x,", req->old_id );
2655 fprintf( stderr, " old_instance=%p,", req->old_instance );
2656 fprintf( stderr, " old_user_data=%lx,", req->old_user_data );
2657 fprintf( stderr, " old_extra_value=%lx", req->old_extra_value );
2660 static void dump_set_parent_request( const struct set_parent_request *req )
2662 fprintf( stderr, " handle=%p,", req->handle );
2663 fprintf( stderr, " parent=%p", req->parent );
2666 static void dump_set_parent_reply( const struct set_parent_reply *req )
2668 fprintf( stderr, " old_parent=%p,", req->old_parent );
2669 fprintf( stderr, " full_parent=%p", req->full_parent );
2672 static void dump_get_window_parents_request( const struct get_window_parents_request *req )
2674 fprintf( stderr, " handle=%p", req->handle );
2677 static void dump_get_window_parents_reply( const struct get_window_parents_reply *req )
2679 fprintf( stderr, " count=%d,", req->count );
2680 fprintf( stderr, " parents=" );
2681 dump_varargs_user_handles( cur_size );
2684 static void dump_get_window_children_request( const struct get_window_children_request *req )
2686 fprintf( stderr, " desktop=%p,", req->desktop );
2687 fprintf( stderr, " parent=%p,", req->parent );
2688 fprintf( stderr, " atom=%04x,", req->atom );
2689 fprintf( stderr, " tid=%04x,", req->tid );
2690 fprintf( stderr, " class=" );
2691 dump_varargs_unicode_str( cur_size );
2694 static void dump_get_window_children_reply( const struct get_window_children_reply *req )
2696 fprintf( stderr, " count=%d,", req->count );
2697 fprintf( stderr, " children=" );
2698 dump_varargs_user_handles( cur_size );
2701 static void dump_get_window_children_from_point_request( const struct get_window_children_from_point_request *req )
2703 fprintf( stderr, " parent=%p,", req->parent );
2704 fprintf( stderr, " x=%d,", req->x );
2705 fprintf( stderr, " y=%d", req->y );
2708 static void dump_get_window_children_from_point_reply( const struct get_window_children_from_point_reply *req )
2710 fprintf( stderr, " count=%d,", req->count );
2711 fprintf( stderr, " children=" );
2712 dump_varargs_user_handles( cur_size );
2715 static void dump_get_window_tree_request( const struct get_window_tree_request *req )
2717 fprintf( stderr, " handle=%p", req->handle );
2720 static void dump_get_window_tree_reply( const struct get_window_tree_reply *req )
2722 fprintf( stderr, " parent=%p,", req->parent );
2723 fprintf( stderr, " owner=%p,", req->owner );
2724 fprintf( stderr, " next_sibling=%p,", req->next_sibling );
2725 fprintf( stderr, " prev_sibling=%p,", req->prev_sibling );
2726 fprintf( stderr, " first_sibling=%p,", req->first_sibling );
2727 fprintf( stderr, " last_sibling=%p,", req->last_sibling );
2728 fprintf( stderr, " first_child=%p,", req->first_child );
2729 fprintf( stderr, " last_child=%p", req->last_child );
2732 static void dump_set_window_pos_request( const struct set_window_pos_request *req )
2734 fprintf( stderr, " flags=%08x,", req->flags );
2735 fprintf( stderr, " handle=%p,", req->handle );
2736 fprintf( stderr, " previous=%p,", req->previous );
2737 fprintf( stderr, " window=" );
2738 dump_rectangle( &req->window );
2739 fprintf( stderr, "," );
2740 fprintf( stderr, " client=" );
2741 dump_rectangle( &req->client );
2742 fprintf( stderr, "," );
2743 fprintf( stderr, " valid=" );
2744 dump_varargs_rectangles( cur_size );
2747 static void dump_set_window_pos_reply( const struct set_window_pos_reply *req )
2749 fprintf( stderr, " new_style=%08x,", req->new_style );
2750 fprintf( stderr, " new_ex_style=%08x", req->new_ex_style );
2753 static void dump_get_window_rectangles_request( const struct get_window_rectangles_request *req )
2755 fprintf( stderr, " handle=%p", req->handle );
2758 static void dump_get_window_rectangles_reply( const struct get_window_rectangles_reply *req )
2760 fprintf( stderr, " window=" );
2761 dump_rectangle( &req->window );
2762 fprintf( stderr, "," );
2763 fprintf( stderr, " visible=" );
2764 dump_rectangle( &req->visible );
2765 fprintf( stderr, "," );
2766 fprintf( stderr, " client=" );
2767 dump_rectangle( &req->client );
2770 static void dump_get_window_text_request( const struct get_window_text_request *req )
2772 fprintf( stderr, " handle=%p", req->handle );
2775 static void dump_get_window_text_reply( const struct get_window_text_reply *req )
2777 fprintf( stderr, " text=" );
2778 dump_varargs_unicode_str( cur_size );
2781 static void dump_set_window_text_request( const struct set_window_text_request *req )
2783 fprintf( stderr, " handle=%p,", req->handle );
2784 fprintf( stderr, " text=" );
2785 dump_varargs_unicode_str( cur_size );
2788 static void dump_get_windows_offset_request( const struct get_windows_offset_request *req )
2790 fprintf( stderr, " from=%p,", req->from );
2791 fprintf( stderr, " to=%p", req->to );
2794 static void dump_get_windows_offset_reply( const struct get_windows_offset_reply *req )
2796 fprintf( stderr, " x=%d,", req->x );
2797 fprintf( stderr, " y=%d", req->y );
2800 static void dump_get_visible_region_request( const struct get_visible_region_request *req )
2802 fprintf( stderr, " window=%p,", req->window );
2803 fprintf( stderr, " flags=%08x", req->flags );
2806 static void dump_get_visible_region_reply( const struct get_visible_region_reply *req )
2808 fprintf( stderr, " top_win=%p,", req->top_win );
2809 fprintf( stderr, " top_rect=" );
2810 dump_rectangle( &req->top_rect );
2811 fprintf( stderr, "," );
2812 fprintf( stderr, " win_rect=" );
2813 dump_rectangle( &req->win_rect );
2814 fprintf( stderr, "," );
2815 fprintf( stderr, " total_size=%u,", req->total_size );
2816 fprintf( stderr, " region=" );
2817 dump_varargs_rectangles( cur_size );
2820 static void dump_get_window_region_request( const struct get_window_region_request *req )
2822 fprintf( stderr, " window=%p", req->window );
2825 static void dump_get_window_region_reply( const struct get_window_region_reply *req )
2827 fprintf( stderr, " total_size=%u,", req->total_size );
2828 fprintf( stderr, " region=" );
2829 dump_varargs_rectangles( cur_size );
2832 static void dump_set_window_region_request( const struct set_window_region_request *req )
2834 fprintf( stderr, " window=%p,", req->window );
2835 fprintf( stderr, " redraw=%d,", req->redraw );
2836 fprintf( stderr, " region=" );
2837 dump_varargs_rectangles( cur_size );
2840 static void dump_get_update_region_request( const struct get_update_region_request *req )
2842 fprintf( stderr, " window=%p,", req->window );
2843 fprintf( stderr, " from_child=%p,", req->from_child );
2844 fprintf( stderr, " flags=%08x", req->flags );
2847 static void dump_get_update_region_reply( const struct get_update_region_reply *req )
2849 fprintf( stderr, " child=%p,", req->child );
2850 fprintf( stderr, " flags=%08x,", req->flags );
2851 fprintf( stderr, " total_size=%u,", req->total_size );
2852 fprintf( stderr, " region=" );
2853 dump_varargs_rectangles( cur_size );
2856 static void dump_update_window_zorder_request( const struct update_window_zorder_request *req )
2858 fprintf( stderr, " window=%p,", req->window );
2859 fprintf( stderr, " rect=" );
2860 dump_rectangle( &req->rect );
2863 static void dump_redraw_window_request( const struct redraw_window_request *req )
2865 fprintf( stderr, " window=%p,", req->window );
2866 fprintf( stderr, " flags=%08x,", req->flags );
2867 fprintf( stderr, " region=" );
2868 dump_varargs_rectangles( cur_size );
2871 static void dump_set_window_property_request( const struct set_window_property_request *req )
2873 fprintf( stderr, " window=%p,", req->window );
2874 fprintf( stderr, " atom=%04x,", req->atom );
2875 fprintf( stderr, " handle=%p,", req->handle );
2876 fprintf( stderr, " name=" );
2877 dump_varargs_unicode_str( cur_size );
2880 static void dump_remove_window_property_request( const struct remove_window_property_request *req )
2882 fprintf( stderr, " window=%p,", req->window );
2883 fprintf( stderr, " atom=%04x,", req->atom );
2884 fprintf( stderr, " name=" );
2885 dump_varargs_unicode_str( cur_size );
2888 static void dump_remove_window_property_reply( const struct remove_window_property_reply *req )
2890 fprintf( stderr, " handle=%p", req->handle );
2893 static void dump_get_window_property_request( const struct get_window_property_request *req )
2895 fprintf( stderr, " window=%p,", req->window );
2896 fprintf( stderr, " atom=%04x,", req->atom );
2897 fprintf( stderr, " name=" );
2898 dump_varargs_unicode_str( cur_size );
2901 static void dump_get_window_property_reply( const struct get_window_property_reply *req )
2903 fprintf( stderr, " handle=%p", req->handle );
2906 static void dump_get_window_properties_request( const struct get_window_properties_request *req )
2908 fprintf( stderr, " window=%p", req->window );
2911 static void dump_get_window_properties_reply( const struct get_window_properties_reply *req )
2913 fprintf( stderr, " total=%d,", req->total );
2914 fprintf( stderr, " props=" );
2915 dump_varargs_properties( cur_size );
2918 static void dump_create_winstation_request( const struct create_winstation_request *req )
2920 fprintf( stderr, " flags=%08x,", req->flags );
2921 fprintf( stderr, " access=%08x,", req->access );
2922 fprintf( stderr, " attributes=%08x,", req->attributes );
2923 fprintf( stderr, " name=" );
2924 dump_varargs_unicode_str( cur_size );
2927 static void dump_create_winstation_reply( const struct create_winstation_reply *req )
2929 fprintf( stderr, " handle=%p", req->handle );
2932 static void dump_open_winstation_request( const struct open_winstation_request *req )
2934 fprintf( stderr, " access=%08x,", req->access );
2935 fprintf( stderr, " attributes=%08x,", req->attributes );
2936 fprintf( stderr, " name=" );
2937 dump_varargs_unicode_str( cur_size );
2940 static void dump_open_winstation_reply( const struct open_winstation_reply *req )
2942 fprintf( stderr, " handle=%p", req->handle );
2945 static void dump_close_winstation_request( const struct close_winstation_request *req )
2947 fprintf( stderr, " handle=%p", req->handle );
2950 static void dump_get_process_winstation_request( const struct get_process_winstation_request *req )
2954 static void dump_get_process_winstation_reply( const struct get_process_winstation_reply *req )
2956 fprintf( stderr, " handle=%p", req->handle );
2959 static void dump_set_process_winstation_request( const struct set_process_winstation_request *req )
2961 fprintf( stderr, " handle=%p", req->handle );
2964 static void dump_enum_winstation_request( const struct enum_winstation_request *req )
2966 fprintf( stderr, " index=%08x", req->index );
2969 static void dump_enum_winstation_reply( const struct enum_winstation_reply *req )
2971 fprintf( stderr, " next=%08x,", req->next );
2972 fprintf( stderr, " name=" );
2973 dump_varargs_unicode_str( cur_size );
2976 static void dump_create_desktop_request( const struct create_desktop_request *req )
2978 fprintf( stderr, " flags=%08x,", req->flags );
2979 fprintf( stderr, " access=%08x,", req->access );
2980 fprintf( stderr, " attributes=%08x,", req->attributes );
2981 fprintf( stderr, " name=" );
2982 dump_varargs_unicode_str( cur_size );
2985 static void dump_create_desktop_reply( const struct create_desktop_reply *req )
2987 fprintf( stderr, " handle=%p", req->handle );
2990 static void dump_open_desktop_request( const struct open_desktop_request *req )
2992 fprintf( stderr, " winsta=%p,", req->winsta );
2993 fprintf( stderr, " flags=%08x,", req->flags );
2994 fprintf( stderr, " access=%08x,", req->access );
2995 fprintf( stderr, " attributes=%08x,", req->attributes );
2996 fprintf( stderr, " name=" );
2997 dump_varargs_unicode_str( cur_size );
3000 static void dump_open_desktop_reply( const struct open_desktop_reply *req )
3002 fprintf( stderr, " handle=%p", req->handle );
3005 static void dump_close_desktop_request( const struct close_desktop_request *req )
3007 fprintf( stderr, " handle=%p", req->handle );
3010 static void dump_get_thread_desktop_request( const struct get_thread_desktop_request *req )
3012 fprintf( stderr, " tid=%04x", req->tid );
3015 static void dump_get_thread_desktop_reply( const struct get_thread_desktop_reply *req )
3017 fprintf( stderr, " handle=%p", req->handle );
3020 static void dump_set_thread_desktop_request( const struct set_thread_desktop_request *req )
3022 fprintf( stderr, " handle=%p", req->handle );
3025 static void dump_enum_desktop_request( const struct enum_desktop_request *req )
3027 fprintf( stderr, " winstation=%p,", req->winstation );
3028 fprintf( stderr, " index=%08x", req->index );
3031 static void dump_enum_desktop_reply( const struct enum_desktop_reply *req )
3033 fprintf( stderr, " next=%08x,", req->next );
3034 fprintf( stderr, " name=" );
3035 dump_varargs_unicode_str( cur_size );
3038 static void dump_set_user_object_info_request( const struct set_user_object_info_request *req )
3040 fprintf( stderr, " handle=%p,", req->handle );
3041 fprintf( stderr, " flags=%08x,", req->flags );
3042 fprintf( stderr, " obj_flags=%08x", req->obj_flags );
3045 static void dump_set_user_object_info_reply( const struct set_user_object_info_reply *req )
3047 fprintf( stderr, " is_desktop=%d,", req->is_desktop );
3048 fprintf( stderr, " old_obj_flags=%08x,", req->old_obj_flags );
3049 fprintf( stderr, " name=" );
3050 dump_varargs_unicode_str( cur_size );
3053 static void dump_attach_thread_input_request( const struct attach_thread_input_request *req )
3055 fprintf( stderr, " tid_from=%04x,", req->tid_from );
3056 fprintf( stderr, " tid_to=%04x,", req->tid_to );
3057 fprintf( stderr, " attach=%d", req->attach );
3060 static void dump_get_thread_input_request( const struct get_thread_input_request *req )
3062 fprintf( stderr, " tid=%04x", req->tid );
3065 static void dump_get_thread_input_reply( const struct get_thread_input_reply *req )
3067 fprintf( stderr, " focus=%p,", req->focus );
3068 fprintf( stderr, " capture=%p,", req->capture );
3069 fprintf( stderr, " active=%p,", req->active );
3070 fprintf( stderr, " foreground=%p,", req->foreground );
3071 fprintf( stderr, " menu_owner=%p,", req->menu_owner );
3072 fprintf( stderr, " move_size=%p,", req->move_size );
3073 fprintf( stderr, " caret=%p,", req->caret );
3074 fprintf( stderr, " rect=" );
3075 dump_rectangle( &req->rect );
3078 static void dump_get_last_input_time_request( const struct get_last_input_time_request *req )
3082 static void dump_get_last_input_time_reply( const struct get_last_input_time_reply *req )
3084 fprintf( stderr, " time=%08x", req->time );
3087 static void dump_get_key_state_request( const struct get_key_state_request *req )
3089 fprintf( stderr, " tid=%04x,", req->tid );
3090 fprintf( stderr, " key=%d", req->key );
3093 static void dump_get_key_state_reply( const struct get_key_state_reply *req )
3095 fprintf( stderr, " state=%02x,", req->state );
3096 fprintf( stderr, " keystate=" );
3097 dump_varargs_bytes( cur_size );
3100 static void dump_set_key_state_request( const struct set_key_state_request *req )
3102 fprintf( stderr, " tid=%04x,", req->tid );
3103 fprintf( stderr, " keystate=" );
3104 dump_varargs_bytes( cur_size );
3107 static void dump_set_foreground_window_request( const struct set_foreground_window_request *req )
3109 fprintf( stderr, " handle=%p", req->handle );
3112 static void dump_set_foreground_window_reply( const struct set_foreground_window_reply *req )
3114 fprintf( stderr, " previous=%p,", req->previous );
3115 fprintf( stderr, " send_msg_old=%d,", req->send_msg_old );
3116 fprintf( stderr, " send_msg_new=%d", req->send_msg_new );
3119 static void dump_set_focus_window_request( const struct set_focus_window_request *req )
3121 fprintf( stderr, " handle=%p", req->handle );
3124 static void dump_set_focus_window_reply( const struct set_focus_window_reply *req )
3126 fprintf( stderr, " previous=%p", req->previous );
3129 static void dump_set_active_window_request( const struct set_active_window_request *req )
3131 fprintf( stderr, " handle=%p", req->handle );
3134 static void dump_set_active_window_reply( const struct set_active_window_reply *req )
3136 fprintf( stderr, " previous=%p", req->previous );
3139 static void dump_set_capture_window_request( const struct set_capture_window_request *req )
3141 fprintf( stderr, " handle=%p,", req->handle );
3142 fprintf( stderr, " flags=%08x", req->flags );
3145 static void dump_set_capture_window_reply( const struct set_capture_window_reply *req )
3147 fprintf( stderr, " previous=%p,", req->previous );
3148 fprintf( stderr, " full_handle=%p", req->full_handle );
3151 static void dump_set_caret_window_request( const struct set_caret_window_request *req )
3153 fprintf( stderr, " handle=%p,", req->handle );
3154 fprintf( stderr, " width=%d,", req->width );
3155 fprintf( stderr, " height=%d", req->height );
3158 static void dump_set_caret_window_reply( const struct set_caret_window_reply *req )
3160 fprintf( stderr, " previous=%p,", req->previous );
3161 fprintf( stderr, " old_rect=" );
3162 dump_rectangle( &req->old_rect );
3163 fprintf( stderr, "," );
3164 fprintf( stderr, " old_hide=%d,", req->old_hide );
3165 fprintf( stderr, " old_state=%d", req->old_state );
3168 static void dump_set_caret_info_request( const struct set_caret_info_request *req )
3170 fprintf( stderr, " flags=%08x,", req->flags );
3171 fprintf( stderr, " handle=%p,", req->handle );
3172 fprintf( stderr, " x=%d,", req->x );
3173 fprintf( stderr, " y=%d,", req->y );
3174 fprintf( stderr, " hide=%d,", req->hide );
3175 fprintf( stderr, " state=%d", req->state );
3178 static void dump_set_caret_info_reply( const struct set_caret_info_reply *req )
3180 fprintf( stderr, " full_handle=%p,", req->full_handle );
3181 fprintf( stderr, " old_rect=" );
3182 dump_rectangle( &req->old_rect );
3183 fprintf( stderr, "," );
3184 fprintf( stderr, " old_hide=%d,", req->old_hide );
3185 fprintf( stderr, " old_state=%d", req->old_state );
3188 static void dump_set_hook_request( const struct set_hook_request *req )
3190 fprintf( stderr, " id=%d,", req->id );
3191 fprintf( stderr, " pid=%04x,", req->pid );
3192 fprintf( stderr, " tid=%04x,", req->tid );
3193 fprintf( stderr, " event_min=%d,", req->event_min );
3194 fprintf( stderr, " event_max=%d,", req->event_max );
3195 fprintf( stderr, " flags=%d,", req->flags );
3196 fprintf( stderr, " proc=%p,", req->proc );
3197 fprintf( stderr, " unicode=%d,", req->unicode );
3198 fprintf( stderr, " module=" );
3199 dump_varargs_unicode_str( cur_size );
3202 static void dump_set_hook_reply( const struct set_hook_reply *req )
3204 fprintf( stderr, " handle=%p,", req->handle );
3205 fprintf( stderr, " active_hooks=%08x", req->active_hooks );
3208 static void dump_remove_hook_request( const struct remove_hook_request *req )
3210 fprintf( stderr, " handle=%p,", req->handle );
3211 fprintf( stderr, " id=%d,", req->id );
3212 fprintf( stderr, " proc=%p", req->proc );
3215 static void dump_remove_hook_reply( const struct remove_hook_reply *req )
3217 fprintf( stderr, " active_hooks=%08x", req->active_hooks );
3220 static void dump_start_hook_chain_request( const struct start_hook_chain_request *req )
3222 fprintf( stderr, " id=%d,", req->id );
3223 fprintf( stderr, " event=%d,", req->event );
3224 fprintf( stderr, " window=%p,", req->window );
3225 fprintf( stderr, " object_id=%d,", req->object_id );
3226 fprintf( stderr, " child_id=%d", req->child_id );
3229 static void dump_start_hook_chain_reply( const struct start_hook_chain_reply *req )
3231 fprintf( stderr, " handle=%p,", req->handle );
3232 fprintf( stderr, " pid=%04x,", req->pid );
3233 fprintf( stderr, " tid=%04x,", req->tid );
3234 fprintf( stderr, " proc=%p,", req->proc );
3235 fprintf( stderr, " unicode=%d,", req->unicode );
3236 fprintf( stderr, " active_hooks=%08x,", req->active_hooks );
3237 fprintf( stderr, " module=" );
3238 dump_varargs_unicode_str( cur_size );
3241 static void dump_finish_hook_chain_request( const struct finish_hook_chain_request *req )
3243 fprintf( stderr, " id=%d", req->id );
3246 static void dump_get_hook_info_request( const struct get_hook_info_request *req )
3248 fprintf( stderr, " handle=%p,", req->handle );
3249 fprintf( stderr, " get_next=%d,", req->get_next );
3250 fprintf( stderr, " event=%d,", req->event );
3251 fprintf( stderr, " window=%p,", req->window );
3252 fprintf( stderr, " object_id=%d,", req->object_id );
3253 fprintf( stderr, " child_id=%d", req->child_id );
3256 static void dump_get_hook_info_reply( const struct get_hook_info_reply *req )
3258 fprintf( stderr, " handle=%p,", req->handle );
3259 fprintf( stderr, " id=%d,", req->id );
3260 fprintf( stderr, " pid=%04x,", req->pid );
3261 fprintf( stderr, " tid=%04x,", req->tid );
3262 fprintf( stderr, " proc=%p,", req->proc );
3263 fprintf( stderr, " unicode=%d,", req->unicode );
3264 fprintf( stderr, " module=" );
3265 dump_varargs_unicode_str( cur_size );
3268 static void dump_create_class_request( const struct create_class_request *req )
3270 fprintf( stderr, " local=%d,", req->local );
3271 fprintf( stderr, " atom=%04x,", req->atom );
3272 fprintf( stderr, " style=%08x,", req->style );
3273 fprintf( stderr, " instance=%p,", req->instance );
3274 fprintf( stderr, " extra=%d,", req->extra );
3275 fprintf( stderr, " win_extra=%d,", req->win_extra );
3276 fprintf( stderr, " client_ptr=%p,", req->client_ptr );
3277 fprintf( stderr, " name=" );
3278 dump_varargs_unicode_str( cur_size );
3281 static void dump_create_class_reply( const struct create_class_reply *req )
3283 fprintf( stderr, " atom=%04x", req->atom );
3286 static void dump_destroy_class_request( const struct destroy_class_request *req )
3288 fprintf( stderr, " atom=%04x,", req->atom );
3289 fprintf( stderr, " instance=%p,", req->instance );
3290 fprintf( stderr, " name=" );
3291 dump_varargs_unicode_str( cur_size );
3294 static void dump_destroy_class_reply( const struct destroy_class_reply *req )
3296 fprintf( stderr, " client_ptr=%p", req->client_ptr );
3299 static void dump_set_class_info_request( const struct set_class_info_request *req )
3301 fprintf( stderr, " window=%p,", req->window );
3302 fprintf( stderr, " flags=%08x,", req->flags );
3303 fprintf( stderr, " atom=%04x,", req->atom );
3304 fprintf( stderr, " style=%08x,", req->style );
3305 fprintf( stderr, " win_extra=%d,", req->win_extra );
3306 fprintf( stderr, " instance=%p,", req->instance );
3307 fprintf( stderr, " extra_offset=%d,", req->extra_offset );
3308 fprintf( stderr, " extra_size=%u,", req->extra_size );
3309 fprintf( stderr, " extra_value=%lx", req->extra_value );
3312 static void dump_set_class_info_reply( const struct set_class_info_reply *req )
3314 fprintf( stderr, " old_atom=%04x,", req->old_atom );
3315 fprintf( stderr, " old_style=%08x,", req->old_style );
3316 fprintf( stderr, " old_extra=%d,", req->old_extra );
3317 fprintf( stderr, " old_win_extra=%d,", req->old_win_extra );
3318 fprintf( stderr, " old_instance=%p,", req->old_instance );
3319 fprintf( stderr, " old_extra_value=%lx", req->old_extra_value );
3322 static void dump_set_clipboard_info_request( const struct set_clipboard_info_request *req )
3324 fprintf( stderr, " flags=%08x,", req->flags );
3325 fprintf( stderr, " clipboard=%p,", req->clipboard );
3326 fprintf( stderr, " owner=%p,", req->owner );
3327 fprintf( stderr, " viewer=%p,", req->viewer );
3328 fprintf( stderr, " seqno=%08x", req->seqno );
3331 static void dump_set_clipboard_info_reply( const struct set_clipboard_info_reply *req )
3333 fprintf( stderr, " flags=%08x,", req->flags );
3334 fprintf( stderr, " old_clipboard=%p,", req->old_clipboard );
3335 fprintf( stderr, " old_owner=%p,", req->old_owner );
3336 fprintf( stderr, " old_viewer=%p,", req->old_viewer );
3337 fprintf( stderr, " seqno=%08x", req->seqno );
3340 static void dump_open_token_request( const struct open_token_request *req )
3342 fprintf( stderr, " handle=%p,", req->handle );
3343 fprintf( stderr, " access=%08x,", req->access );
3344 fprintf( stderr, " attributes=%08x,", req->attributes );
3345 fprintf( stderr, " flags=%08x", req->flags );
3348 static void dump_open_token_reply( const struct open_token_reply *req )
3350 fprintf( stderr, " token=%p", req->token );
3353 static void dump_set_global_windows_request( const struct set_global_windows_request *req )
3355 fprintf( stderr, " flags=%08x,", req->flags );
3356 fprintf( stderr, " shell_window=%p,", req->shell_window );
3357 fprintf( stderr, " shell_listview=%p,", req->shell_listview );
3358 fprintf( stderr, " progman_window=%p,", req->progman_window );
3359 fprintf( stderr, " taskman_window=%p", req->taskman_window );
3362 static void dump_set_global_windows_reply( const struct set_global_windows_reply *req )
3364 fprintf( stderr, " old_shell_window=%p,", req->old_shell_window );
3365 fprintf( stderr, " old_shell_listview=%p,", req->old_shell_listview );
3366 fprintf( stderr, " old_progman_window=%p,", req->old_progman_window );
3367 fprintf( stderr, " old_taskman_window=%p", req->old_taskman_window );
3370 static void dump_adjust_token_privileges_request( const struct adjust_token_privileges_request *req )
3372 fprintf( stderr, " handle=%p,", req->handle );
3373 fprintf( stderr, " disable_all=%d,", req->disable_all );
3374 fprintf( stderr, " get_modified_state=%d,", req->get_modified_state );
3375 fprintf( stderr, " privileges=" );
3376 dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
3379 static void dump_adjust_token_privileges_reply( const struct adjust_token_privileges_reply *req )
3381 fprintf( stderr, " len=%08x,", req->len );
3382 fprintf( stderr, " privileges=" );
3383 dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
3386 static void dump_get_token_privileges_request( const struct get_token_privileges_request *req )
3388 fprintf( stderr, " handle=%p", req->handle );
3391 static void dump_get_token_privileges_reply( const struct get_token_privileges_reply *req )
3393 fprintf( stderr, " len=%08x,", req->len );
3394 fprintf( stderr, " privileges=" );
3395 dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
3398 static void dump_check_token_privileges_request( const struct check_token_privileges_request *req )
3400 fprintf( stderr, " handle=%p,", req->handle );
3401 fprintf( stderr, " all_required=%d,", req->all_required );
3402 fprintf( stderr, " privileges=" );
3403 dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
3406 static void dump_check_token_privileges_reply( const struct check_token_privileges_reply *req )
3408 fprintf( stderr, " has_privileges=%d,", req->has_privileges );
3409 fprintf( stderr, " privileges=" );
3410 dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
3413 static void dump_duplicate_token_request( const struct duplicate_token_request *req )
3415 fprintf( stderr, " handle=%p,", req->handle );
3416 fprintf( stderr, " access=%08x,", req->access );
3417 fprintf( stderr, " attributes=%08x,", req->attributes );
3418 fprintf( stderr, " primary=%d,", req->primary );
3419 fprintf( stderr, " impersonation_level=%d", req->impersonation_level );
3422 static void dump_duplicate_token_reply( const struct duplicate_token_reply *req )
3424 fprintf( stderr, " new_handle=%p", req->new_handle );
3427 static void dump_access_check_request( const struct access_check_request *req )
3429 fprintf( stderr, " handle=%p,", req->handle );
3430 fprintf( stderr, " desired_access=%08x,", req->desired_access );
3431 fprintf( stderr, " mapping_read=%08x,", req->mapping_read );
3432 fprintf( stderr, " mapping_write=%08x,", req->mapping_write );
3433 fprintf( stderr, " mapping_execute=%08x,", req->mapping_execute );
3434 fprintf( stderr, " mapping_all=%08x,", req->mapping_all );
3435 fprintf( stderr, " sd=" );
3436 dump_varargs_security_descriptor( cur_size );
3439 static void dump_access_check_reply( const struct access_check_reply *req )
3441 fprintf( stderr, " access_granted=%08x,", req->access_granted );
3442 fprintf( stderr, " access_status=%08x,", req->access_status );
3443 fprintf( stderr, " privileges_len=%08x,", req->privileges_len );
3444 fprintf( stderr, " privileges=" );
3445 dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
3448 static void dump_get_token_user_request( const struct get_token_user_request *req )
3450 fprintf( stderr, " handle=%p", req->handle );
3453 static void dump_get_token_user_reply( const struct get_token_user_reply *req )
3455 fprintf( stderr, " user_len=%u,", req->user_len );
3456 fprintf( stderr, " user=" );
3457 dump_varargs_SID( cur_size );
3460 static void dump_get_token_groups_request( const struct get_token_groups_request *req )
3462 fprintf( stderr, " handle=%p", req->handle );
3465 static void dump_get_token_groups_reply( const struct get_token_groups_reply *req )
3467 fprintf( stderr, " user_len=%u,", req->user_len );
3468 fprintf( stderr, " user=" );
3469 dump_varargs_token_groups( cur_size );
3472 static void dump_set_security_object_request( const struct set_security_object_request *req )
3474 fprintf( stderr, " handle=%p,", req->handle );
3475 fprintf( stderr, " security_info=%08x,", req->security_info );
3476 fprintf( stderr, " sd=" );
3477 dump_varargs_security_descriptor( cur_size );
3480 static void dump_get_security_object_request( const struct get_security_object_request *req )
3482 fprintf( stderr, " handle=%p,", req->handle );
3483 fprintf( stderr, " security_info=%08x", req->security_info );
3486 static void dump_get_security_object_reply( const struct get_security_object_reply *req )
3488 fprintf( stderr, " sd_len=%08x,", req->sd_len );
3489 fprintf( stderr, " sd=" );
3490 dump_varargs_security_descriptor( cur_size );
3493 static void dump_create_mailslot_request( const struct create_mailslot_request *req )
3495 fprintf( stderr, " access=%08x,", req->access );
3496 fprintf( stderr, " attributes=%08x,", req->attributes );
3497 fprintf( stderr, " rootdir=%p,", req->rootdir );
3498 fprintf( stderr, " max_msgsize=%08x,", req->max_msgsize );
3499 fprintf( stderr, " read_timeout=" );
3500 dump_timeout( &req->read_timeout );
3501 fprintf( stderr, "," );
3502 fprintf( stderr, " name=" );
3503 dump_varargs_unicode_str( cur_size );
3506 static void dump_create_mailslot_reply( const struct create_mailslot_reply *req )
3508 fprintf( stderr, " handle=%p", req->handle );
3511 static void dump_set_mailslot_info_request( const struct set_mailslot_info_request *req )
3513 fprintf( stderr, " handle=%p,", req->handle );
3514 fprintf( stderr, " flags=%08x,", req->flags );
3515 fprintf( stderr, " read_timeout=" );
3516 dump_timeout( &req->read_timeout );
3519 static void dump_set_mailslot_info_reply( const struct set_mailslot_info_reply *req )
3521 fprintf( stderr, " max_msgsize=%08x,", req->max_msgsize );
3522 fprintf( stderr, " read_timeout=" );
3523 dump_timeout( &req->read_timeout );
3526 static void dump_create_directory_request( const struct create_directory_request *req )
3528 fprintf( stderr, " access=%08x,", req->access );
3529 fprintf( stderr, " attributes=%08x,", req->attributes );
3530 fprintf( stderr, " rootdir=%p,", req->rootdir );
3531 fprintf( stderr, " directory_name=" );
3532 dump_varargs_unicode_str( cur_size );
3535 static void dump_create_directory_reply( const struct create_directory_reply *req )
3537 fprintf( stderr, " handle=%p", req->handle );
3540 static void dump_open_directory_request( const struct open_directory_request *req )
3542 fprintf( stderr, " access=%08x,", req->access );
3543 fprintf( stderr, " attributes=%08x,", req->attributes );
3544 fprintf( stderr, " rootdir=%p,", req->rootdir );
3545 fprintf( stderr, " directory_name=" );
3546 dump_varargs_unicode_str( cur_size );
3549 static void dump_open_directory_reply( const struct open_directory_reply *req )
3551 fprintf( stderr, " handle=%p", req->handle );
3554 static void dump_get_directory_entry_request( const struct get_directory_entry_request *req )
3556 fprintf( stderr, " handle=%p,", req->handle );
3557 fprintf( stderr, " index=%08x", req->index );
3560 static void dump_get_directory_entry_reply( const struct get_directory_entry_reply *req )
3562 fprintf( stderr, " name_len=%lu,", (unsigned long)req->name_len );
3563 fprintf( stderr, " name=" );
3564 dump_varargs_unicode_str( min(cur_size,req->name_len) );
3565 fputc( ',', stderr );
3566 fprintf( stderr, " type=" );
3567 dump_varargs_unicode_str( cur_size );
3570 static void dump_create_symlink_request( const struct create_symlink_request *req )
3572 fprintf( stderr, " access=%08x,", req->access );
3573 fprintf( stderr, " attributes=%08x,", req->attributes );
3574 fprintf( stderr, " rootdir=%p,", req->rootdir );
3575 fprintf( stderr, " name_len=%u,", req->name_len );
3576 fprintf( stderr, " name=" );
3577 dump_varargs_unicode_str( min(cur_size,req->name_len) );
3578 fputc( ',', stderr );
3579 fprintf( stderr, " target_name=" );
3580 dump_varargs_unicode_str( cur_size );
3583 static void dump_create_symlink_reply( const struct create_symlink_reply *req )
3585 fprintf( stderr, " handle=%p", req->handle );
3588 static void dump_open_symlink_request( const struct open_symlink_request *req )
3590 fprintf( stderr, " access=%08x,", req->access );
3591 fprintf( stderr, " attributes=%08x,", req->attributes );
3592 fprintf( stderr, " rootdir=%p,", req->rootdir );
3593 fprintf( stderr, " name=" );
3594 dump_varargs_unicode_str( cur_size );
3597 static void dump_open_symlink_reply( const struct open_symlink_reply *req )
3599 fprintf( stderr, " handle=%p", req->handle );
3602 static void dump_query_symlink_request( const struct query_symlink_request *req )
3604 fprintf( stderr, " handle=%p", req->handle );
3607 static void dump_query_symlink_reply( const struct query_symlink_reply *req )
3609 fprintf( stderr, " target_name=" );
3610 dump_varargs_unicode_str( cur_size );
3613 static void dump_get_object_info_request( const struct get_object_info_request *req )
3615 fprintf( stderr, " handle=%p", req->handle );
3618 static void dump_get_object_info_reply( const struct get_object_info_reply *req )
3620 fprintf( stderr, " access=%08x,", req->access );
3621 fprintf( stderr, " ref_count=%08x", req->ref_count );
3624 static void dump_unlink_object_request( const struct unlink_object_request *req )
3626 fprintf( stderr, " handle=%p", req->handle );
3629 static void dump_get_token_impersonation_level_request( const struct get_token_impersonation_level_request *req )
3631 fprintf( stderr, " handle=%p", req->handle );
3634 static void dump_get_token_impersonation_level_reply( const struct get_token_impersonation_level_reply *req )
3636 fprintf( stderr, " impersonation_level=%d", req->impersonation_level );
3639 static void dump_allocate_locally_unique_id_request( const struct allocate_locally_unique_id_request *req )
3643 static void dump_allocate_locally_unique_id_reply( const struct allocate_locally_unique_id_reply *req )
3645 fprintf( stderr, " luid=" );
3646 dump_luid( &req->luid );
3649 static void dump_create_device_manager_request( const struct create_device_manager_request *req )
3651 fprintf( stderr, " access=%08x,", req->access );
3652 fprintf( stderr, " attributes=%08x", req->attributes );
3655 static void dump_create_device_manager_reply( const struct create_device_manager_reply *req )
3657 fprintf( stderr, " handle=%p", req->handle );
3660 static void dump_create_device_request( const struct create_device_request *req )
3662 fprintf( stderr, " access=%08x,", req->access );
3663 fprintf( stderr, " attributes=%08x,", req->attributes );
3664 fprintf( stderr, " rootdir=%p,", req->rootdir );
3665 fprintf( stderr, " manager=%p,", req->manager );
3666 fprintf( stderr, " user_ptr=%p,", req->user_ptr );
3667 fprintf( stderr, " name=" );
3668 dump_varargs_unicode_str( cur_size );
3671 static void dump_create_device_reply( const struct create_device_reply *req )
3673 fprintf( stderr, " handle=%p", req->handle );
3676 static void dump_delete_device_request( const struct delete_device_request *req )
3678 fprintf( stderr, " handle=%p", req->handle );
3681 static void dump_get_next_device_request_request( const struct get_next_device_request_request *req )
3683 fprintf( stderr, " manager=%p,", req->manager );
3684 fprintf( stderr, " prev=%p,", req->prev );
3685 fprintf( stderr, " status=%08x,", req->status );
3686 fprintf( stderr, " prev_data=" );
3687 dump_varargs_bytes( cur_size );
3690 static void dump_get_next_device_request_reply( const struct get_next_device_request_reply *req )
3692 fprintf( stderr, " next=%p,", req->next );
3693 fprintf( stderr, " code=" );
3694 dump_ioctl_code( &req->code );
3695 fprintf( stderr, "," );
3696 fprintf( stderr, " user_ptr=%p,", req->user_ptr );
3697 fprintf( stderr, " in_size=%u,", req->in_size );
3698 fprintf( stderr, " out_size=%u,", req->out_size );
3699 fprintf( stderr, " next_data=" );
3700 dump_varargs_bytes( cur_size );
3703 static void dump_make_process_system_request( const struct make_process_system_request *req )
3707 static void dump_make_process_system_reply( const struct make_process_system_reply *req )
3709 fprintf( stderr, " event=%p", req->event );
3712 static void dump_get_token_statistics_request( const struct get_token_statistics_request *req )
3714 fprintf( stderr, " handle=%p", req->handle );
3717 static void dump_get_token_statistics_reply( const struct get_token_statistics_reply *req )
3719 fprintf( stderr, " token_id=" );
3720 dump_luid( &req->token_id );
3721 fprintf( stderr, "," );
3722 fprintf( stderr, " modified_id=" );
3723 dump_luid( &req->modified_id );
3724 fprintf( stderr, "," );
3725 fprintf( stderr, " primary=%d,", req->primary );
3726 fprintf( stderr, " impersonation_level=%d,", req->impersonation_level );
3727 fprintf( stderr, " group_count=%d,", req->group_count );
3728 fprintf( stderr, " privilege_count=%d", req->privilege_count );
3731 static void dump_create_completion_request( const struct create_completion_request *req )
3733 fprintf( stderr, " access=%08x,", req->access );
3734 fprintf( stderr, " attributes=%08x,", req->attributes );
3735 fprintf( stderr, " concurrent=%08x,", req->concurrent );
3736 fprintf( stderr, " rootdir=%p,", req->rootdir );
3737 fprintf( stderr, " filename=" );
3738 dump_varargs_string( cur_size );
3741 static void dump_create_completion_reply( const struct create_completion_reply *req )
3743 fprintf( stderr, " handle=%p", req->handle );
3746 static void dump_open_completion_request( const struct open_completion_request *req )
3748 fprintf( stderr, " access=%08x,", req->access );
3749 fprintf( stderr, " attributes=%08x,", req->attributes );
3750 fprintf( stderr, " rootdir=%p,", req->rootdir );
3751 fprintf( stderr, " filename=" );
3752 dump_varargs_string( cur_size );
3755 static void dump_open_completion_reply( const struct open_completion_reply *req )
3757 fprintf( stderr, " handle=%p", req->handle );
3760 static void dump_add_completion_request( const struct add_completion_request *req )
3762 fprintf( stderr, " handle=%p,", req->handle );
3763 fprintf( stderr, " ckey=%lx,", req->ckey );
3764 fprintf( stderr, " cvalue=%lx,", req->cvalue );
3765 fprintf( stderr, " information=%lx,", req->information );
3766 fprintf( stderr, " status=%08x", req->status );
3769 static void dump_remove_completion_request( const struct remove_completion_request *req )
3771 fprintf( stderr, " handle=%p", req->handle );
3774 static void dump_remove_completion_reply( const struct remove_completion_reply *req )
3776 fprintf( stderr, " ckey=%lx,", req->ckey );
3777 fprintf( stderr, " cvalue=%lx,", req->cvalue );
3778 fprintf( stderr, " information=%lx,", req->information );
3779 fprintf( stderr, " status=%08x", req->status );
3782 static void dump_query_completion_request( const struct query_completion_request *req )
3784 fprintf( stderr, " handle=%p", req->handle );
3787 static void dump_query_completion_reply( const struct query_completion_reply *req )
3789 fprintf( stderr, " depth=%08x", req->depth );
3792 static void dump_set_completion_info_request( const struct set_completion_info_request *req )
3794 fprintf( stderr, " handle=%p,", req->handle );
3795 fprintf( stderr, " chandle=%p,", req->chandle );
3796 fprintf( stderr, " ckey=%lx", req->ckey );
3799 static void dump_add_fd_completion_request( const struct add_fd_completion_request *req )
3801 fprintf( stderr, " handle=%p,", req->handle );
3802 fprintf( stderr, " cvalue=%lx,", req->cvalue );
3803 fprintf( stderr, " status=%08x,", req->status );
3804 fprintf( stderr, " information=%lx", req->information );
3807 static void dump_get_window_layered_info_request( const struct get_window_layered_info_request *req )
3809 fprintf( stderr, " handle=%p", req->handle );
3812 static void dump_get_window_layered_info_reply( const struct get_window_layered_info_reply *req )
3814 fprintf( stderr, " color_key=%08x,", req->color_key );
3815 fprintf( stderr, " alpha=%08x,", req->alpha );
3816 fprintf( stderr, " flags=%08x", req->flags );
3819 static void dump_set_window_layered_info_request( const struct set_window_layered_info_request *req )
3821 fprintf( stderr, " handle=%p,", req->handle );
3822 fprintf( stderr, " color_key=%08x,", req->color_key );
3823 fprintf( stderr, " alpha=%08x,", req->alpha );
3824 fprintf( stderr, " flags=%08x", req->flags );
3827 static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
3828 (dump_func)dump_new_process_request,
3829 (dump_func)dump_get_new_process_info_request,
3830 (dump_func)dump_new_thread_request,
3831 (dump_func)dump_get_startup_info_request,
3832 (dump_func)dump_init_process_done_request,
3833 (dump_func)dump_init_thread_request,
3834 (dump_func)dump_terminate_process_request,
3835 (dump_func)dump_terminate_thread_request,
3836 (dump_func)dump_get_process_info_request,
3837 (dump_func)dump_set_process_info_request,
3838 (dump_func)dump_get_thread_info_request,
3839 (dump_func)dump_set_thread_info_request,
3840 (dump_func)dump_get_dll_info_request,
3841 (dump_func)dump_suspend_thread_request,
3842 (dump_func)dump_resume_thread_request,
3843 (dump_func)dump_load_dll_request,
3844 (dump_func)dump_unload_dll_request,
3845 (dump_func)dump_queue_apc_request,
3846 (dump_func)dump_get_apc_result_request,
3847 (dump_func)dump_close_handle_request,
3848 (dump_func)dump_set_handle_info_request,
3849 (dump_func)dump_dup_handle_request,
3850 (dump_func)dump_open_process_request,
3851 (dump_func)dump_open_thread_request,
3852 (dump_func)dump_select_request,
3853 (dump_func)dump_create_event_request,
3854 (dump_func)dump_event_op_request,
3855 (dump_func)dump_open_event_request,
3856 (dump_func)dump_create_mutex_request,
3857 (dump_func)dump_release_mutex_request,
3858 (dump_func)dump_open_mutex_request,
3859 (dump_func)dump_create_semaphore_request,
3860 (dump_func)dump_release_semaphore_request,
3861 (dump_func)dump_open_semaphore_request,
3862 (dump_func)dump_create_file_request,
3863 (dump_func)dump_open_file_object_request,
3864 (dump_func)dump_alloc_file_handle_request,
3865 (dump_func)dump_get_handle_fd_request,
3866 (dump_func)dump_flush_file_request,
3867 (dump_func)dump_lock_file_request,
3868 (dump_func)dump_unlock_file_request,
3869 (dump_func)dump_create_socket_request,
3870 (dump_func)dump_accept_socket_request,
3871 (dump_func)dump_set_socket_event_request,
3872 (dump_func)dump_get_socket_event_request,
3873 (dump_func)dump_enable_socket_event_request,
3874 (dump_func)dump_set_socket_deferred_request,
3875 (dump_func)dump_alloc_console_request,
3876 (dump_func)dump_free_console_request,
3877 (dump_func)dump_get_console_renderer_events_request,
3878 (dump_func)dump_open_console_request,
3879 (dump_func)dump_get_console_wait_event_request,
3880 (dump_func)dump_get_console_mode_request,
3881 (dump_func)dump_set_console_mode_request,
3882 (dump_func)dump_set_console_input_info_request,
3883 (dump_func)dump_get_console_input_info_request,
3884 (dump_func)dump_append_console_input_history_request,
3885 (dump_func)dump_get_console_input_history_request,
3886 (dump_func)dump_create_console_output_request,
3887 (dump_func)dump_set_console_output_info_request,
3888 (dump_func)dump_get_console_output_info_request,
3889 (dump_func)dump_write_console_input_request,
3890 (dump_func)dump_read_console_input_request,
3891 (dump_func)dump_write_console_output_request,
3892 (dump_func)dump_fill_console_output_request,
3893 (dump_func)dump_read_console_output_request,
3894 (dump_func)dump_move_console_output_request,
3895 (dump_func)dump_send_console_signal_request,
3896 (dump_func)dump_read_directory_changes_request,
3897 (dump_func)dump_read_change_request,
3898 (dump_func)dump_create_mapping_request,
3899 (dump_func)dump_open_mapping_request,
3900 (dump_func)dump_get_mapping_info_request,
3901 (dump_func)dump_get_mapping_committed_range_request,
3902 (dump_func)dump_add_mapping_committed_range_request,
3903 (dump_func)dump_create_snapshot_request,
3904 (dump_func)dump_next_process_request,
3905 (dump_func)dump_next_thread_request,
3906 (dump_func)dump_next_module_request,
3907 (dump_func)dump_wait_debug_event_request,
3908 (dump_func)dump_queue_exception_event_request,
3909 (dump_func)dump_get_exception_status_request,
3910 (dump_func)dump_output_debug_string_request,
3911 (dump_func)dump_continue_debug_event_request,
3912 (dump_func)dump_debug_process_request,
3913 (dump_func)dump_debug_break_request,
3914 (dump_func)dump_set_debugger_kill_on_exit_request,
3915 (dump_func)dump_read_process_memory_request,
3916 (dump_func)dump_write_process_memory_request,
3917 (dump_func)dump_create_key_request,
3918 (dump_func)dump_open_key_request,
3919 (dump_func)dump_delete_key_request,
3920 (dump_func)dump_flush_key_request,
3921 (dump_func)dump_enum_key_request,
3922 (dump_func)dump_set_key_value_request,
3923 (dump_func)dump_get_key_value_request,
3924 (dump_func)dump_enum_key_value_request,
3925 (dump_func)dump_delete_key_value_request,
3926 (dump_func)dump_load_registry_request,
3927 (dump_func)dump_unload_registry_request,
3928 (dump_func)dump_save_registry_request,
3929 (dump_func)dump_set_registry_notification_request,
3930 (dump_func)dump_create_timer_request,
3931 (dump_func)dump_open_timer_request,
3932 (dump_func)dump_set_timer_request,
3933 (dump_func)dump_cancel_timer_request,
3934 (dump_func)dump_get_timer_info_request,
3935 (dump_func)dump_get_thread_context_request,
3936 (dump_func)dump_set_thread_context_request,
3937 (dump_func)dump_get_selector_entry_request,
3938 (dump_func)dump_add_atom_request,
3939 (dump_func)dump_delete_atom_request,
3940 (dump_func)dump_find_atom_request,
3941 (dump_func)dump_get_atom_information_request,
3942 (dump_func)dump_set_atom_information_request,
3943 (dump_func)dump_empty_atom_table_request,
3944 (dump_func)dump_init_atom_table_request,
3945 (dump_func)dump_get_msg_queue_request,
3946 (dump_func)dump_set_queue_fd_request,
3947 (dump_func)dump_set_queue_mask_request,
3948 (dump_func)dump_get_queue_status_request,
3949 (dump_func)dump_get_process_idle_event_request,
3950 (dump_func)dump_send_message_request,
3951 (dump_func)dump_post_quit_message_request,
3952 (dump_func)dump_send_hardware_message_request,
3953 (dump_func)dump_get_message_request,
3954 (dump_func)dump_reply_message_request,
3955 (dump_func)dump_accept_hardware_message_request,
3956 (dump_func)dump_get_message_reply_request,
3957 (dump_func)dump_set_win_timer_request,
3958 (dump_func)dump_kill_win_timer_request,
3959 (dump_func)dump_is_window_hung_request,
3960 (dump_func)dump_get_serial_info_request,
3961 (dump_func)dump_set_serial_info_request,
3962 (dump_func)dump_register_async_request,
3963 (dump_func)dump_cancel_async_request,
3964 (dump_func)dump_ioctl_request,
3965 (dump_func)dump_get_ioctl_result_request,
3966 (dump_func)dump_create_named_pipe_request,
3967 (dump_func)dump_get_named_pipe_info_request,
3968 (dump_func)dump_create_window_request,
3969 (dump_func)dump_destroy_window_request,
3970 (dump_func)dump_get_desktop_window_request,
3971 (dump_func)dump_set_window_owner_request,
3972 (dump_func)dump_get_window_info_request,
3973 (dump_func)dump_set_window_info_request,
3974 (dump_func)dump_set_parent_request,
3975 (dump_func)dump_get_window_parents_request,
3976 (dump_func)dump_get_window_children_request,
3977 (dump_func)dump_get_window_children_from_point_request,
3978 (dump_func)dump_get_window_tree_request,
3979 (dump_func)dump_set_window_pos_request,
3980 (dump_func)dump_get_window_rectangles_request,
3981 (dump_func)dump_get_window_text_request,
3982 (dump_func)dump_set_window_text_request,
3983 (dump_func)dump_get_windows_offset_request,
3984 (dump_func)dump_get_visible_region_request,
3985 (dump_func)dump_get_window_region_request,
3986 (dump_func)dump_set_window_region_request,
3987 (dump_func)dump_get_update_region_request,
3988 (dump_func)dump_update_window_zorder_request,
3989 (dump_func)dump_redraw_window_request,
3990 (dump_func)dump_set_window_property_request,
3991 (dump_func)dump_remove_window_property_request,
3992 (dump_func)dump_get_window_property_request,
3993 (dump_func)dump_get_window_properties_request,
3994 (dump_func)dump_create_winstation_request,
3995 (dump_func)dump_open_winstation_request,
3996 (dump_func)dump_close_winstation_request,
3997 (dump_func)dump_get_process_winstation_request,
3998 (dump_func)dump_set_process_winstation_request,
3999 (dump_func)dump_enum_winstation_request,
4000 (dump_func)dump_create_desktop_request,
4001 (dump_func)dump_open_desktop_request,
4002 (dump_func)dump_close_desktop_request,
4003 (dump_func)dump_get_thread_desktop_request,
4004 (dump_func)dump_set_thread_desktop_request,
4005 (dump_func)dump_enum_desktop_request,
4006 (dump_func)dump_set_user_object_info_request,
4007 (dump_func)dump_attach_thread_input_request,
4008 (dump_func)dump_get_thread_input_request,
4009 (dump_func)dump_get_last_input_time_request,
4010 (dump_func)dump_get_key_state_request,
4011 (dump_func)dump_set_key_state_request,
4012 (dump_func)dump_set_foreground_window_request,
4013 (dump_func)dump_set_focus_window_request,
4014 (dump_func)dump_set_active_window_request,
4015 (dump_func)dump_set_capture_window_request,
4016 (dump_func)dump_set_caret_window_request,
4017 (dump_func)dump_set_caret_info_request,
4018 (dump_func)dump_set_hook_request,
4019 (dump_func)dump_remove_hook_request,
4020 (dump_func)dump_start_hook_chain_request,
4021 (dump_func)dump_finish_hook_chain_request,
4022 (dump_func)dump_get_hook_info_request,
4023 (dump_func)dump_create_class_request,
4024 (dump_func)dump_destroy_class_request,
4025 (dump_func)dump_set_class_info_request,
4026 (dump_func)dump_set_clipboard_info_request,
4027 (dump_func)dump_open_token_request,
4028 (dump_func)dump_set_global_windows_request,
4029 (dump_func)dump_adjust_token_privileges_request,
4030 (dump_func)dump_get_token_privileges_request,
4031 (dump_func)dump_check_token_privileges_request,
4032 (dump_func)dump_duplicate_token_request,
4033 (dump_func)dump_access_check_request,
4034 (dump_func)dump_get_token_user_request,
4035 (dump_func)dump_get_token_groups_request,
4036 (dump_func)dump_set_security_object_request,
4037 (dump_func)dump_get_security_object_request,
4038 (dump_func)dump_create_mailslot_request,
4039 (dump_func)dump_set_mailslot_info_request,
4040 (dump_func)dump_create_directory_request,
4041 (dump_func)dump_open_directory_request,
4042 (dump_func)dump_get_directory_entry_request,
4043 (dump_func)dump_create_symlink_request,
4044 (dump_func)dump_open_symlink_request,
4045 (dump_func)dump_query_symlink_request,
4046 (dump_func)dump_get_object_info_request,
4047 (dump_func)dump_unlink_object_request,
4048 (dump_func)dump_get_token_impersonation_level_request,
4049 (dump_func)dump_allocate_locally_unique_id_request,
4050 (dump_func)dump_create_device_manager_request,
4051 (dump_func)dump_create_device_request,
4052 (dump_func)dump_delete_device_request,
4053 (dump_func)dump_get_next_device_request_request,
4054 (dump_func)dump_make_process_system_request,
4055 (dump_func)dump_get_token_statistics_request,
4056 (dump_func)dump_create_completion_request,
4057 (dump_func)dump_open_completion_request,
4058 (dump_func)dump_add_completion_request,
4059 (dump_func)dump_remove_completion_request,
4060 (dump_func)dump_query_completion_request,
4061 (dump_func)dump_set_completion_info_request,
4062 (dump_func)dump_add_fd_completion_request,
4063 (dump_func)dump_get_window_layered_info_request,
4064 (dump_func)dump_set_window_layered_info_request,
4067 static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
4068 (dump_func)dump_new_process_reply,
4069 (dump_func)dump_get_new_process_info_reply,
4070 (dump_func)dump_new_thread_reply,
4071 (dump_func)dump_get_startup_info_reply,
4072 NULL,
4073 (dump_func)dump_init_thread_reply,
4074 (dump_func)dump_terminate_process_reply,
4075 (dump_func)dump_terminate_thread_reply,
4076 (dump_func)dump_get_process_info_reply,
4077 NULL,
4078 (dump_func)dump_get_thread_info_reply,
4079 NULL,
4080 (dump_func)dump_get_dll_info_reply,
4081 (dump_func)dump_suspend_thread_reply,
4082 (dump_func)dump_resume_thread_reply,
4083 NULL,
4084 NULL,
4085 (dump_func)dump_queue_apc_reply,
4086 (dump_func)dump_get_apc_result_reply,
4087 NULL,
4088 (dump_func)dump_set_handle_info_reply,
4089 (dump_func)dump_dup_handle_reply,
4090 (dump_func)dump_open_process_reply,
4091 (dump_func)dump_open_thread_reply,
4092 (dump_func)dump_select_reply,
4093 (dump_func)dump_create_event_reply,
4094 NULL,
4095 (dump_func)dump_open_event_reply,
4096 (dump_func)dump_create_mutex_reply,
4097 (dump_func)dump_release_mutex_reply,
4098 (dump_func)dump_open_mutex_reply,
4099 (dump_func)dump_create_semaphore_reply,
4100 (dump_func)dump_release_semaphore_reply,
4101 (dump_func)dump_open_semaphore_reply,
4102 (dump_func)dump_create_file_reply,
4103 (dump_func)dump_open_file_object_reply,
4104 (dump_func)dump_alloc_file_handle_reply,
4105 (dump_func)dump_get_handle_fd_reply,
4106 (dump_func)dump_flush_file_reply,
4107 (dump_func)dump_lock_file_reply,
4108 NULL,
4109 (dump_func)dump_create_socket_reply,
4110 (dump_func)dump_accept_socket_reply,
4111 NULL,
4112 (dump_func)dump_get_socket_event_reply,
4113 NULL,
4114 NULL,
4115 (dump_func)dump_alloc_console_reply,
4116 NULL,
4117 (dump_func)dump_get_console_renderer_events_reply,
4118 (dump_func)dump_open_console_reply,
4119 (dump_func)dump_get_console_wait_event_reply,
4120 (dump_func)dump_get_console_mode_reply,
4121 NULL,
4122 NULL,
4123 (dump_func)dump_get_console_input_info_reply,
4124 NULL,
4125 (dump_func)dump_get_console_input_history_reply,
4126 (dump_func)dump_create_console_output_reply,
4127 NULL,
4128 (dump_func)dump_get_console_output_info_reply,
4129 (dump_func)dump_write_console_input_reply,
4130 (dump_func)dump_read_console_input_reply,
4131 (dump_func)dump_write_console_output_reply,
4132 (dump_func)dump_fill_console_output_reply,
4133 (dump_func)dump_read_console_output_reply,
4134 NULL,
4135 NULL,
4136 NULL,
4137 (dump_func)dump_read_change_reply,
4138 (dump_func)dump_create_mapping_reply,
4139 (dump_func)dump_open_mapping_reply,
4140 (dump_func)dump_get_mapping_info_reply,
4141 (dump_func)dump_get_mapping_committed_range_reply,
4142 NULL,
4143 (dump_func)dump_create_snapshot_reply,
4144 (dump_func)dump_next_process_reply,
4145 (dump_func)dump_next_thread_reply,
4146 (dump_func)dump_next_module_reply,
4147 (dump_func)dump_wait_debug_event_reply,
4148 (dump_func)dump_queue_exception_event_reply,
4149 (dump_func)dump_get_exception_status_reply,
4150 NULL,
4151 NULL,
4152 NULL,
4153 (dump_func)dump_debug_break_reply,
4154 NULL,
4155 (dump_func)dump_read_process_memory_reply,
4156 NULL,
4157 (dump_func)dump_create_key_reply,
4158 (dump_func)dump_open_key_reply,
4159 NULL,
4160 NULL,
4161 (dump_func)dump_enum_key_reply,
4162 NULL,
4163 (dump_func)dump_get_key_value_reply,
4164 (dump_func)dump_enum_key_value_reply,
4165 NULL,
4166 NULL,
4167 NULL,
4168 NULL,
4169 NULL,
4170 (dump_func)dump_create_timer_reply,
4171 (dump_func)dump_open_timer_reply,
4172 (dump_func)dump_set_timer_reply,
4173 (dump_func)dump_cancel_timer_reply,
4174 (dump_func)dump_get_timer_info_reply,
4175 (dump_func)dump_get_thread_context_reply,
4176 (dump_func)dump_set_thread_context_reply,
4177 (dump_func)dump_get_selector_entry_reply,
4178 (dump_func)dump_add_atom_reply,
4179 NULL,
4180 (dump_func)dump_find_atom_reply,
4181 (dump_func)dump_get_atom_information_reply,
4182 NULL,
4183 NULL,
4184 (dump_func)dump_init_atom_table_reply,
4185 (dump_func)dump_get_msg_queue_reply,
4186 NULL,
4187 (dump_func)dump_set_queue_mask_reply,
4188 (dump_func)dump_get_queue_status_reply,
4189 (dump_func)dump_get_process_idle_event_reply,
4190 NULL,
4191 NULL,
4192 NULL,
4193 (dump_func)dump_get_message_reply,
4194 NULL,
4195 NULL,
4196 (dump_func)dump_get_message_reply_reply,
4197 (dump_func)dump_set_win_timer_reply,
4198 NULL,
4199 (dump_func)dump_is_window_hung_reply,
4200 (dump_func)dump_get_serial_info_reply,
4201 NULL,
4202 NULL,
4203 NULL,
4204 (dump_func)dump_ioctl_reply,
4205 (dump_func)dump_get_ioctl_result_reply,
4206 (dump_func)dump_create_named_pipe_reply,
4207 (dump_func)dump_get_named_pipe_info_reply,
4208 (dump_func)dump_create_window_reply,
4209 NULL,
4210 (dump_func)dump_get_desktop_window_reply,
4211 (dump_func)dump_set_window_owner_reply,
4212 (dump_func)dump_get_window_info_reply,
4213 (dump_func)dump_set_window_info_reply,
4214 (dump_func)dump_set_parent_reply,
4215 (dump_func)dump_get_window_parents_reply,
4216 (dump_func)dump_get_window_children_reply,
4217 (dump_func)dump_get_window_children_from_point_reply,
4218 (dump_func)dump_get_window_tree_reply,
4219 (dump_func)dump_set_window_pos_reply,
4220 (dump_func)dump_get_window_rectangles_reply,
4221 (dump_func)dump_get_window_text_reply,
4222 NULL,
4223 (dump_func)dump_get_windows_offset_reply,
4224 (dump_func)dump_get_visible_region_reply,
4225 (dump_func)dump_get_window_region_reply,
4226 NULL,
4227 (dump_func)dump_get_update_region_reply,
4228 NULL,
4229 NULL,
4230 NULL,
4231 (dump_func)dump_remove_window_property_reply,
4232 (dump_func)dump_get_window_property_reply,
4233 (dump_func)dump_get_window_properties_reply,
4234 (dump_func)dump_create_winstation_reply,
4235 (dump_func)dump_open_winstation_reply,
4236 NULL,
4237 (dump_func)dump_get_process_winstation_reply,
4238 NULL,
4239 (dump_func)dump_enum_winstation_reply,
4240 (dump_func)dump_create_desktop_reply,
4241 (dump_func)dump_open_desktop_reply,
4242 NULL,
4243 (dump_func)dump_get_thread_desktop_reply,
4244 NULL,
4245 (dump_func)dump_enum_desktop_reply,
4246 (dump_func)dump_set_user_object_info_reply,
4247 NULL,
4248 (dump_func)dump_get_thread_input_reply,
4249 (dump_func)dump_get_last_input_time_reply,
4250 (dump_func)dump_get_key_state_reply,
4251 NULL,
4252 (dump_func)dump_set_foreground_window_reply,
4253 (dump_func)dump_set_focus_window_reply,
4254 (dump_func)dump_set_active_window_reply,
4255 (dump_func)dump_set_capture_window_reply,
4256 (dump_func)dump_set_caret_window_reply,
4257 (dump_func)dump_set_caret_info_reply,
4258 (dump_func)dump_set_hook_reply,
4259 (dump_func)dump_remove_hook_reply,
4260 (dump_func)dump_start_hook_chain_reply,
4261 NULL,
4262 (dump_func)dump_get_hook_info_reply,
4263 (dump_func)dump_create_class_reply,
4264 (dump_func)dump_destroy_class_reply,
4265 (dump_func)dump_set_class_info_reply,
4266 (dump_func)dump_set_clipboard_info_reply,
4267 (dump_func)dump_open_token_reply,
4268 (dump_func)dump_set_global_windows_reply,
4269 (dump_func)dump_adjust_token_privileges_reply,
4270 (dump_func)dump_get_token_privileges_reply,
4271 (dump_func)dump_check_token_privileges_reply,
4272 (dump_func)dump_duplicate_token_reply,
4273 (dump_func)dump_access_check_reply,
4274 (dump_func)dump_get_token_user_reply,
4275 (dump_func)dump_get_token_groups_reply,
4276 NULL,
4277 (dump_func)dump_get_security_object_reply,
4278 (dump_func)dump_create_mailslot_reply,
4279 (dump_func)dump_set_mailslot_info_reply,
4280 (dump_func)dump_create_directory_reply,
4281 (dump_func)dump_open_directory_reply,
4282 (dump_func)dump_get_directory_entry_reply,
4283 (dump_func)dump_create_symlink_reply,
4284 (dump_func)dump_open_symlink_reply,
4285 (dump_func)dump_query_symlink_reply,
4286 (dump_func)dump_get_object_info_reply,
4287 NULL,
4288 (dump_func)dump_get_token_impersonation_level_reply,
4289 (dump_func)dump_allocate_locally_unique_id_reply,
4290 (dump_func)dump_create_device_manager_reply,
4291 (dump_func)dump_create_device_reply,
4292 NULL,
4293 (dump_func)dump_get_next_device_request_reply,
4294 (dump_func)dump_make_process_system_reply,
4295 (dump_func)dump_get_token_statistics_reply,
4296 (dump_func)dump_create_completion_reply,
4297 (dump_func)dump_open_completion_reply,
4298 NULL,
4299 (dump_func)dump_remove_completion_reply,
4300 (dump_func)dump_query_completion_reply,
4301 NULL,
4302 NULL,
4303 (dump_func)dump_get_window_layered_info_reply,
4304 NULL,
4307 static const char * const req_names[REQ_NB_REQUESTS] = {
4308 "new_process",
4309 "get_new_process_info",
4310 "new_thread",
4311 "get_startup_info",
4312 "init_process_done",
4313 "init_thread",
4314 "terminate_process",
4315 "terminate_thread",
4316 "get_process_info",
4317 "set_process_info",
4318 "get_thread_info",
4319 "set_thread_info",
4320 "get_dll_info",
4321 "suspend_thread",
4322 "resume_thread",
4323 "load_dll",
4324 "unload_dll",
4325 "queue_apc",
4326 "get_apc_result",
4327 "close_handle",
4328 "set_handle_info",
4329 "dup_handle",
4330 "open_process",
4331 "open_thread",
4332 "select",
4333 "create_event",
4334 "event_op",
4335 "open_event",
4336 "create_mutex",
4337 "release_mutex",
4338 "open_mutex",
4339 "create_semaphore",
4340 "release_semaphore",
4341 "open_semaphore",
4342 "create_file",
4343 "open_file_object",
4344 "alloc_file_handle",
4345 "get_handle_fd",
4346 "flush_file",
4347 "lock_file",
4348 "unlock_file",
4349 "create_socket",
4350 "accept_socket",
4351 "set_socket_event",
4352 "get_socket_event",
4353 "enable_socket_event",
4354 "set_socket_deferred",
4355 "alloc_console",
4356 "free_console",
4357 "get_console_renderer_events",
4358 "open_console",
4359 "get_console_wait_event",
4360 "get_console_mode",
4361 "set_console_mode",
4362 "set_console_input_info",
4363 "get_console_input_info",
4364 "append_console_input_history",
4365 "get_console_input_history",
4366 "create_console_output",
4367 "set_console_output_info",
4368 "get_console_output_info",
4369 "write_console_input",
4370 "read_console_input",
4371 "write_console_output",
4372 "fill_console_output",
4373 "read_console_output",
4374 "move_console_output",
4375 "send_console_signal",
4376 "read_directory_changes",
4377 "read_change",
4378 "create_mapping",
4379 "open_mapping",
4380 "get_mapping_info",
4381 "get_mapping_committed_range",
4382 "add_mapping_committed_range",
4383 "create_snapshot",
4384 "next_process",
4385 "next_thread",
4386 "next_module",
4387 "wait_debug_event",
4388 "queue_exception_event",
4389 "get_exception_status",
4390 "output_debug_string",
4391 "continue_debug_event",
4392 "debug_process",
4393 "debug_break",
4394 "set_debugger_kill_on_exit",
4395 "read_process_memory",
4396 "write_process_memory",
4397 "create_key",
4398 "open_key",
4399 "delete_key",
4400 "flush_key",
4401 "enum_key",
4402 "set_key_value",
4403 "get_key_value",
4404 "enum_key_value",
4405 "delete_key_value",
4406 "load_registry",
4407 "unload_registry",
4408 "save_registry",
4409 "set_registry_notification",
4410 "create_timer",
4411 "open_timer",
4412 "set_timer",
4413 "cancel_timer",
4414 "get_timer_info",
4415 "get_thread_context",
4416 "set_thread_context",
4417 "get_selector_entry",
4418 "add_atom",
4419 "delete_atom",
4420 "find_atom",
4421 "get_atom_information",
4422 "set_atom_information",
4423 "empty_atom_table",
4424 "init_atom_table",
4425 "get_msg_queue",
4426 "set_queue_fd",
4427 "set_queue_mask",
4428 "get_queue_status",
4429 "get_process_idle_event",
4430 "send_message",
4431 "post_quit_message",
4432 "send_hardware_message",
4433 "get_message",
4434 "reply_message",
4435 "accept_hardware_message",
4436 "get_message_reply",
4437 "set_win_timer",
4438 "kill_win_timer",
4439 "is_window_hung",
4440 "get_serial_info",
4441 "set_serial_info",
4442 "register_async",
4443 "cancel_async",
4444 "ioctl",
4445 "get_ioctl_result",
4446 "create_named_pipe",
4447 "get_named_pipe_info",
4448 "create_window",
4449 "destroy_window",
4450 "get_desktop_window",
4451 "set_window_owner",
4452 "get_window_info",
4453 "set_window_info",
4454 "set_parent",
4455 "get_window_parents",
4456 "get_window_children",
4457 "get_window_children_from_point",
4458 "get_window_tree",
4459 "set_window_pos",
4460 "get_window_rectangles",
4461 "get_window_text",
4462 "set_window_text",
4463 "get_windows_offset",
4464 "get_visible_region",
4465 "get_window_region",
4466 "set_window_region",
4467 "get_update_region",
4468 "update_window_zorder",
4469 "redraw_window",
4470 "set_window_property",
4471 "remove_window_property",
4472 "get_window_property",
4473 "get_window_properties",
4474 "create_winstation",
4475 "open_winstation",
4476 "close_winstation",
4477 "get_process_winstation",
4478 "set_process_winstation",
4479 "enum_winstation",
4480 "create_desktop",
4481 "open_desktop",
4482 "close_desktop",
4483 "get_thread_desktop",
4484 "set_thread_desktop",
4485 "enum_desktop",
4486 "set_user_object_info",
4487 "attach_thread_input",
4488 "get_thread_input",
4489 "get_last_input_time",
4490 "get_key_state",
4491 "set_key_state",
4492 "set_foreground_window",
4493 "set_focus_window",
4494 "set_active_window",
4495 "set_capture_window",
4496 "set_caret_window",
4497 "set_caret_info",
4498 "set_hook",
4499 "remove_hook",
4500 "start_hook_chain",
4501 "finish_hook_chain",
4502 "get_hook_info",
4503 "create_class",
4504 "destroy_class",
4505 "set_class_info",
4506 "set_clipboard_info",
4507 "open_token",
4508 "set_global_windows",
4509 "adjust_token_privileges",
4510 "get_token_privileges",
4511 "check_token_privileges",
4512 "duplicate_token",
4513 "access_check",
4514 "get_token_user",
4515 "get_token_groups",
4516 "set_security_object",
4517 "get_security_object",
4518 "create_mailslot",
4519 "set_mailslot_info",
4520 "create_directory",
4521 "open_directory",
4522 "get_directory_entry",
4523 "create_symlink",
4524 "open_symlink",
4525 "query_symlink",
4526 "get_object_info",
4527 "unlink_object",
4528 "get_token_impersonation_level",
4529 "allocate_locally_unique_id",
4530 "create_device_manager",
4531 "create_device",
4532 "delete_device",
4533 "get_next_device_request",
4534 "make_process_system",
4535 "get_token_statistics",
4536 "create_completion",
4537 "open_completion",
4538 "add_completion",
4539 "remove_completion",
4540 "query_completion",
4541 "set_completion_info",
4542 "add_fd_completion",
4543 "get_window_layered_info",
4544 "set_window_layered_info",
4547 static const struct
4549 const char *name;
4550 unsigned int value;
4551 } status_names[] =
4553 { "ABANDONED_WAIT_0", STATUS_ABANDONED_WAIT_0 },
4554 { "ACCESS_DENIED", STATUS_ACCESS_DENIED },
4555 { "ACCESS_VIOLATION", STATUS_ACCESS_VIOLATION },
4556 { "ALERTED", STATUS_ALERTED },
4557 { "ALIAS_EXISTS", STATUS_ALIAS_EXISTS },
4558 { "BAD_DEVICE_TYPE", STATUS_BAD_DEVICE_TYPE },
4559 { "BAD_IMPERSONATION_LEVEL", STATUS_BAD_IMPERSONATION_LEVEL },
4560 { "BREAKPOINT", STATUS_BREAKPOINT },
4561 { "BUFFER_OVERFLOW", STATUS_BUFFER_OVERFLOW },
4562 { "BUFFER_TOO_SMALL", STATUS_BUFFER_TOO_SMALL },
4563 { "CANCELLED", STATUS_CANCELLED },
4564 { "CANT_OPEN_ANONYMOUS", STATUS_CANT_OPEN_ANONYMOUS },
4565 { "CHILD_MUST_BE_VOLATILE", STATUS_CHILD_MUST_BE_VOLATILE },
4566 { "DEBUGGER_INACTIVE", STATUS_DEBUGGER_INACTIVE },
4567 { "DEVICE_BUSY", STATUS_DEVICE_BUSY },
4568 { "DIRECTORY_NOT_EMPTY", STATUS_DIRECTORY_NOT_EMPTY },
4569 { "DISK_FULL", STATUS_DISK_FULL },
4570 { "DLL_NOT_FOUND", STATUS_DLL_NOT_FOUND },
4571 { "ERROR_CLASS_ALREADY_EXISTS", 0xc0010000 | ERROR_CLASS_ALREADY_EXISTS },
4572 { "ERROR_CLASS_DOES_NOT_EXIST", 0xc0010000 | ERROR_CLASS_DOES_NOT_EXIST },
4573 { "ERROR_CLASS_HAS_WINDOWS", 0xc0010000 | ERROR_CLASS_HAS_WINDOWS },
4574 { "ERROR_CLIPBOARD_NOT_OPEN", 0xc0010000 | ERROR_CLIPBOARD_NOT_OPEN },
4575 { "ERROR_INVALID_INDEX", 0xc0010000 | ERROR_INVALID_INDEX },
4576 { "ERROR_INVALID_WINDOW_HANDLE", 0xc0010000 | ERROR_INVALID_WINDOW_HANDLE },
4577 { "FILE_DELETED", STATUS_FILE_DELETED },
4578 { "FILE_IS_A_DIRECTORY", STATUS_FILE_IS_A_DIRECTORY },
4579 { "FILE_LOCK_CONFLICT", STATUS_FILE_LOCK_CONFLICT },
4580 { "GENERIC_NOT_MAPPED", STATUS_GENERIC_NOT_MAPPED },
4581 { "HANDLES_CLOSED", STATUS_HANDLES_CLOSED },
4582 { "HANDLE_NOT_CLOSABLE", STATUS_HANDLE_NOT_CLOSABLE },
4583 { "ILLEGAL_FUNCTION", STATUS_ILLEGAL_FUNCTION },
4584 { "INSTANCE_NOT_AVAILABLE", STATUS_INSTANCE_NOT_AVAILABLE },
4585 { "INSUFFICIENT_RESOURCES", STATUS_INSUFFICIENT_RESOURCES },
4586 { "INVALID_CID", STATUS_INVALID_CID },
4587 { "INVALID_DEVICE_REQUEST", STATUS_INVALID_DEVICE_REQUEST },
4588 { "INVALID_FILE_FOR_SECTION", STATUS_INVALID_FILE_FOR_SECTION },
4589 { "INVALID_HANDLE", STATUS_INVALID_HANDLE },
4590 { "INVALID_PARAMETER", STATUS_INVALID_PARAMETER },
4591 { "INVALID_SECURITY_DESCR", STATUS_INVALID_SECURITY_DESCR },
4592 { "IO_TIMEOUT", STATUS_IO_TIMEOUT },
4593 { "KEY_DELETED", STATUS_KEY_DELETED },
4594 { "MAPPED_FILE_SIZE_ZERO", STATUS_MAPPED_FILE_SIZE_ZERO },
4595 { "MEDIA_WRITE_PROTECTED", STATUS_MEDIA_WRITE_PROTECTED },
4596 { "MUTANT_NOT_OWNED", STATUS_MUTANT_NOT_OWNED },
4597 { "NAME_TOO_LONG", STATUS_NAME_TOO_LONG },
4598 { "NOTIFY_ENUM_DIR", STATUS_NOTIFY_ENUM_DIR },
4599 { "NOT_ALL_ASSIGNED", STATUS_NOT_ALL_ASSIGNED },
4600 { "NOT_A_DIRECTORY", STATUS_NOT_A_DIRECTORY },
4601 { "NOT_IMPLEMENTED", STATUS_NOT_IMPLEMENTED },
4602 { "NOT_REGISTRY_FILE", STATUS_NOT_REGISTRY_FILE },
4603 { "NOT_SUPPORTED", STATUS_NOT_SUPPORTED },
4604 { "NO_DATA_DETECTED", STATUS_NO_DATA_DETECTED },
4605 { "NO_IMPERSONATION_TOKEN", STATUS_NO_IMPERSONATION_TOKEN },
4606 { "NO_MEMORY", STATUS_NO_MEMORY },
4607 { "NO_MORE_ENTRIES", STATUS_NO_MORE_ENTRIES },
4608 { "NO_MORE_FILES", STATUS_NO_MORE_FILES },
4609 { "NO_SUCH_DEVICE", STATUS_NO_SUCH_DEVICE },
4610 { "NO_SUCH_FILE", STATUS_NO_SUCH_FILE },
4611 { "NO_TOKEN", STATUS_NO_TOKEN },
4612 { "OBJECT_NAME_COLLISION", STATUS_OBJECT_NAME_COLLISION },
4613 { "OBJECT_NAME_EXISTS", STATUS_OBJECT_NAME_EXISTS },
4614 { "OBJECT_NAME_INVALID", STATUS_OBJECT_NAME_INVALID },
4615 { "OBJECT_NAME_NOT_FOUND", STATUS_OBJECT_NAME_NOT_FOUND },
4616 { "OBJECT_PATH_INVALID", STATUS_OBJECT_PATH_INVALID },
4617 { "OBJECT_PATH_NOT_FOUND", STATUS_OBJECT_PATH_NOT_FOUND },
4618 { "OBJECT_PATH_SYNTAX_BAD", STATUS_OBJECT_PATH_SYNTAX_BAD },
4619 { "OBJECT_TYPE_MISMATCH", STATUS_OBJECT_TYPE_MISMATCH },
4620 { "PENDING", STATUS_PENDING },
4621 { "PIPE_BUSY", STATUS_PIPE_BUSY },
4622 { "PIPE_CONNECTED", STATUS_PIPE_CONNECTED },
4623 { "PIPE_DISCONNECTED", STATUS_PIPE_DISCONNECTED },
4624 { "PIPE_LISTENING", STATUS_PIPE_LISTENING },
4625 { "PIPE_NOT_AVAILABLE", STATUS_PIPE_NOT_AVAILABLE },
4626 { "PRIVILEGE_NOT_HELD", STATUS_PRIVILEGE_NOT_HELD },
4627 { "PROCESS_IS_TERMINATING", STATUS_PROCESS_IS_TERMINATING },
4628 { "SECTION_TOO_BIG", STATUS_SECTION_TOO_BIG },
4629 { "SEMAPHORE_LIMIT_EXCEEDED", STATUS_SEMAPHORE_LIMIT_EXCEEDED },
4630 { "SHARING_VIOLATION", STATUS_SHARING_VIOLATION },
4631 { "SHUTDOWN_IN_PROGRESS", STATUS_SHUTDOWN_IN_PROGRESS },
4632 { "SUSPEND_COUNT_EXCEEDED", STATUS_SUSPEND_COUNT_EXCEEDED },
4633 { "THREAD_IS_TERMINATING", STATUS_THREAD_IS_TERMINATING },
4634 { "TIMEOUT", STATUS_TIMEOUT },
4635 { "TOO_MANY_OPENED_FILES", STATUS_TOO_MANY_OPENED_FILES },
4636 { "UNSUCCESSFUL", STATUS_UNSUCCESSFUL },
4637 { "USER_APC", STATUS_USER_APC },
4638 { "VOLUME_DISMOUNTED", STATUS_VOLUME_DISMOUNTED },
4639 { "WAS_LOCKED", STATUS_WAS_LOCKED },
4640 { NULL, 0 }
4643 /* ### make_requests end ### */
4644 /* Everything above this line is generated automatically by tools/make_requests */
4646 static const char *get_status_name( unsigned int status )
4648 int i;
4649 static char buffer[10];
4651 if (status)
4653 for (i = 0; status_names[i].name; i++)
4654 if (status_names[i].value == status) return status_names[i].name;
4656 sprintf( buffer, "%x", status );
4657 return buffer;
4660 void trace_request(void)
4662 enum request req = current->req.request_header.req;
4663 if (req < REQ_NB_REQUESTS)
4665 fprintf( stderr, "%04x: %s(", current->id, req_names[req] );
4666 if (req_dumpers[req])
4668 cur_data = get_req_data();
4669 cur_size = get_req_data_size();
4670 req_dumpers[req]( &current->req );
4672 fprintf( stderr, " )\n" );
4674 else fprintf( stderr, "%04x: %d(?)\n", current->id, req );
4677 void trace_reply( enum request req, const union generic_reply *reply )
4679 if (req < REQ_NB_REQUESTS)
4681 fprintf( stderr, "%04x: %s() = %s",
4682 current->id, req_names[req], get_status_name(current->error) );
4683 if (reply_dumpers[req])
4685 fprintf( stderr, " {" );
4686 cur_data = current->reply_data;
4687 cur_size = reply->reply_header.reply_size;
4688 reply_dumpers[req]( reply );
4689 fprintf( stderr, " }" );
4691 fputc( '\n', stderr );
4693 else fprintf( stderr, "%04x: %d() = %s\n",
4694 current->id, req, get_status_name(current->error) );