git.oblomov.eu Git - wine/blob - server/trace.c

   1 /*
   2  * Server request tracing
   3  *
   4  * Copyright (C) 1999 Alexandre Julliard
   5  *
   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.
  10  *
  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.
  15  *
  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
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <ctype.h>
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #include <sys/types.h>
  28
  29 #ifdef HAVE_SYS_UIO_H
  30 #include <sys/uio.h>
  31 #endif
  32
  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"
  43
  44 static const void *cur_data;
  45 static data_size_t cur_size;
  46
  47 static const char *get_status_name( unsigned int status );
  48
  49 /* utility functions */
  50
  51 static inline void remove_data( data_size_t size )
  52 {
  53     cur_data = (const char *)cur_data + size;
  54     cur_size -= size;
  55 }
  56
  57 static void dump_uints( const int *ptr, int len )
  58 {
  59     fputc( '{', stderr );
  60     while (len > 0)
  61     {
  62         fprintf( stderr, "%08x", *ptr++ );
  63         if (--len) fputc( ',', stderr );
  64     }
  65     fputc( '}', stderr );
  66 }
  67
  68 static void dump_timeout( const timeout_t *time )
  69 {
  70     fputs( get_timeout_str(*time), stderr );
  71 }
  72
  73 static void dump_uint64( const unsigned __int64 *val )
  74 {
  75     if ((unsigned int)*val != *val)
  76         fprintf( stderr, "%x%08x", (unsigned int)(*val >> 32), (unsigned int)*val );
  77     else
  78         fprintf( stderr, "%08x", (unsigned int)*val );
  79 }
  80
  81 static void dump_rectangle( const rectangle_t *rect )
  82 {
  83     fprintf( stderr, "{%d,%d;%d,%d}",
  84              rect->left, rect->top, rect->right, rect->bottom );
  85 }
  86
  87 static void dump_char_info( const char_info_t *info )
  88 {
  89     fprintf( stderr, "{'" );
  90     dump_strW( &info->ch, 1, stderr, "\'\'" );
  91     fprintf( stderr, "',%04x}", info->attr );
  92 }
  93
  94 static void dump_ioctl_code( const ioctl_code_t *code )
  95 {
  96     switch(*code)
  97     {
  98 #define CASE(c) case c: fputs( #c, stderr ); break
  99         CASE(FSCTL_DISMOUNT_VOLUME);
 100         CASE(FSCTL_PIPE_DISCONNECT);
 101         CASE(FSCTL_PIPE_LISTEN);
 102         CASE(FSCTL_PIPE_WAIT);
 103         default: fprintf( stderr, "%08x", *code ); break;
 104 #undef CASE
 105     }
 106 }
 107
 108 static void dump_apc_call( const apc_call_t *call )
 109 {
 110     fputc( '{', stderr );
 111     switch(call->type)
 112     {
 113     case APC_NONE:
 114         fprintf( stderr, "APC_NONE" );
 115         break;
 116     case APC_USER:
 117         fprintf( stderr, "APC_USER,args={" );
 118         dump_uint64( &call->user.args[0] );
 119         fputc( ',', stderr );
 120         dump_uint64( &call->user.args[1] );
 121         fputc( ',', stderr );
 122         dump_uint64( &call->user.args[2] );
 123         fputc( '}', stderr );
 124         break;
 125     case APC_TIMER:
 126         fprintf( stderr, "APC_TIMER,time=" );
 127         dump_timeout( &call->timer.time );
 128         fprintf( stderr, ",arg=" );
 129         dump_uint64( &call->timer.arg );
 130         break;
 131     case APC_ASYNC_IO:
 132         fprintf( stderr, "APC_ASYNC_IO,func=%p,user=%p,sb=%p,status=%s",
 133                  call->async_io.func, call->async_io.user, call->async_io.sb,
 134                  get_status_name(call->async_io.status) );
 135         break;
 136     case APC_VIRTUAL_ALLOC:
 137         fprintf( stderr, "APC_VIRTUAL_ALLOC,addr==" );
 138         dump_uint64( &call->virtual_alloc.addr );
 139         fprintf( stderr, ",size=" );
 140         dump_uint64( &call->virtual_alloc.size );
 141         fprintf( stderr, ",zero_bits=%u,op_type=%x,prot=%x",
 142                  call->virtual_alloc.zero_bits, call->virtual_alloc.op_type,
 143                  call->virtual_alloc.prot );
 144         break;
 145     case APC_VIRTUAL_FREE:
 146         fprintf( stderr, "APC_VIRTUAL_FREE,addr=" );
 147         dump_uint64( &call->virtual_free.addr );
 148         fprintf( stderr, ",size=" );
 149         dump_uint64( &call->virtual_free.size );
 150         fprintf( stderr, ",op_type=%x", call->virtual_free.op_type );
 151         break;
 152     case APC_VIRTUAL_QUERY:
 153         fprintf( stderr, "APC_VIRTUAL_QUERY,addr=" );
 154         dump_uint64( &call->virtual_query.addr );
 155         break;
 156     case APC_VIRTUAL_PROTECT:
 157         fprintf( stderr, "APC_VIRTUAL_PROTECT,addr=" );
 158         dump_uint64( &call->virtual_protect.addr );
 159         fprintf( stderr, ",size=" );
 160         dump_uint64( &call->virtual_protect.size );
 161         fprintf( stderr, ",prot=%x", call->virtual_protect.prot );
 162         break;
 163     case APC_VIRTUAL_FLUSH:
 164         fprintf( stderr, "APC_VIRTUAL_FLUSH,addr=" );
 165         dump_uint64( &call->virtual_flush.addr );
 166         fprintf( stderr, ",size=" );
 167         dump_uint64( &call->virtual_flush.size );
 168         break;
 169     case APC_VIRTUAL_LOCK:
 170         fprintf( stderr, "APC_VIRTUAL_LOCK,addr=" );
 171         dump_uint64( &call->virtual_lock.addr );
 172         fprintf( stderr, ",size=" );
 173         dump_uint64( &call->virtual_lock.size );
 174         break;
 175     case APC_VIRTUAL_UNLOCK:
 176         fprintf( stderr, "APC_VIRTUAL_UNLOCK,addr=" );
 177         dump_uint64( &call->virtual_unlock.addr );
 178         fprintf( stderr, ",size=" );
 179         dump_uint64( &call->virtual_unlock.size );
 180         break;
 181     case APC_MAP_VIEW:
 182         fprintf( stderr, "APC_MAP_VIEW,handle=%04x,addr=", call->map_view.handle );
 183         dump_uint64( &call->map_view.addr );
 184         fprintf( stderr, ",size=" );
 185         dump_uint64( &call->map_view.size );
 186         fprintf( stderr, ",offset=" );
 187         dump_uint64( &call->map_view.offset );
 188         fprintf( stderr, ",zero_bits=%u,alloc_type=%x,prot=%x",
 189                  call->map_view.zero_bits, call->map_view.alloc_type, call->map_view.prot );
 190         break;
 191     case APC_UNMAP_VIEW:
 192         fprintf( stderr, "APC_UNMAP_VIEW,addr=" );
 193         dump_uint64( &call->unmap_view.addr );
 194         break;
 195     case APC_CREATE_THREAD:
 196         fprintf( stderr, "APC_CREATE_THREAD,func=" );
 197         dump_uint64( &call->create_thread.func );
 198         fprintf( stderr, ",arg=" );
 199         dump_uint64( &call->create_thread.arg );
 200         fprintf( stderr, ",reserve=" );
 201         dump_uint64( &call->create_thread.reserve );
 202         fprintf( stderr, ",commit=" );
 203         dump_uint64( &call->create_thread.commit );
 204         fprintf( stderr, ",suspend=%u", call->create_thread.suspend );
 205         break;
 206     default:
 207         fprintf( stderr, "type=%u", call->type );
 208         break;
 209     }
 210     fputc( '}', stderr );
 211 }
 212
 213 static void dump_apc_result( const apc_result_t *result )
 214 {
 215     fputc( '{', stderr );
 216     switch(result->type)
 217     {
 218     case APC_NONE:
 219         break;
 220     case APC_ASYNC_IO:
 221         fprintf( stderr, "APC_ASYNC_IO,status=%s,total=%u,apc=%p",
 222                  get_status_name( result->async_io.status ), result->async_io.total, result->async_io.apc );
 223         break;
 224     case APC_VIRTUAL_ALLOC:
 225         fprintf( stderr, "APC_VIRTUAL_ALLOC,status=%s,addr=",
 226                  get_status_name( result->virtual_alloc.status ));
 227         dump_uint64( &result->virtual_alloc.addr );
 228         fprintf( stderr, ",size=" );
 229         dump_uint64( &result->virtual_alloc.size );
 230         break;
 231     case APC_VIRTUAL_FREE:
 232         fprintf( stderr, "APC_VIRTUAL_FREE,status=%s,addr=",
 233                  get_status_name( result->virtual_free.status ));
 234         dump_uint64( &result->virtual_free.addr );
 235         fprintf( stderr, ",size=" );
 236         dump_uint64( &result->virtual_free.size );
 237         break;
 238     case APC_VIRTUAL_QUERY:
 239         fprintf( stderr, "APC_VIRTUAL_QUERY,status=%s,base=",
 240                  get_status_name( result->virtual_query.status ));
 241         dump_uint64( &result->virtual_query.base );
 242         fprintf( stderr, ",alloc_base=" );
 243         dump_uint64( &result->virtual_query.alloc_base );
 244         fprintf( stderr, ",size=" );
 245         dump_uint64( &result->virtual_query.size );
 246         fprintf( stderr, ",state=%x,prot=%x,alloc_prot=%x,alloc_type=%x",
 247                  result->virtual_query.state, result->virtual_query.prot,
 248                  result->virtual_query.alloc_prot, result->virtual_query.alloc_type );
 249         break;
 250     case APC_VIRTUAL_PROTECT:
 251         fprintf( stderr, "APC_VIRTUAL_PROTECT,status=%s,addr=",
 252                  get_status_name( result->virtual_protect.status ));
 253         dump_uint64( &result->virtual_protect.addr );
 254         fprintf( stderr, ",size=" );
 255         dump_uint64( &result->virtual_protect.size );
 256         fprintf( stderr, ",prot=%x", result->virtual_protect.prot );
 257         break;
 258     case APC_VIRTUAL_FLUSH:
 259         fprintf( stderr, "APC_VIRTUAL_FLUSH,status=%s,addr=",
 260                  get_status_name( result->virtual_flush.status ));
 261         dump_uint64( &result->virtual_flush.addr );
 262         fprintf( stderr, ",size=" );
 263         dump_uint64( &result->virtual_flush.size );
 264         break;
 265     case APC_VIRTUAL_LOCK:
 266         fprintf( stderr, "APC_VIRTUAL_LOCK,status=%s,addr=",
 267                  get_status_name( result->virtual_lock.status ));
 268         dump_uint64( &result->virtual_lock.addr );
 269         fprintf( stderr, ",size=" );
 270         dump_uint64( &result->virtual_lock.size );
 271         break;
 272     case APC_VIRTUAL_UNLOCK:
 273         fprintf( stderr, "APC_VIRTUAL_UNLOCK,status=%s,addr=",
 274                  get_status_name( result->virtual_unlock.status ));
 275         dump_uint64( &result->virtual_unlock.addr );
 276         fprintf( stderr, ",size=" );
 277         dump_uint64( &result->virtual_unlock.size );
 278         break;
 279     case APC_MAP_VIEW:
 280         fprintf( stderr, "APC_MAP_VIEW,status=%s,addr=",
 281                  get_status_name( result->map_view.status ));
 282         dump_uint64( &result->map_view.addr );
 283         fprintf( stderr, ",size=" );
 284         dump_uint64( &result->map_view.size );
 285         break;
 286     case APC_UNMAP_VIEW:
 287         fprintf( stderr, "APC_UNMAP_VIEW,status=%s",
 288                  get_status_name( result->unmap_view.status ) );
 289         break;
 290     case APC_CREATE_THREAD:
 291         fprintf( stderr, "APC_CREATE_THREAD,status=%s,tid=%04x,handle=%04x",
 292                  get_status_name( result->create_thread.status ),
 293                  result->create_thread.tid, result->create_thread.handle );
 294         break;
 295     default:
 296         fprintf( stderr, "type=%u", result->type );
 297         break;
 298     }
 299     fputc( '}', stderr );
 300 }
 301
 302 static void dump_async_data( const async_data_t *data )
 303 {
 304     fprintf( stderr, "{handle=%04x,event=%04x,callback=%p,iosb=%p,arg=%p,cvalue=",
 305              data->handle, data->event, data->callback, data->iosb, data->arg );
 306     dump_uint64( &data->cvalue );
 307     fputc( '}', stderr );
 308 }
 309
 310 static void dump_luid( const luid_t *luid )
 311 {
 312     fprintf( stderr, "%d.%u", luid->high_part, luid->low_part );
 313 }
 314
 315 static void dump_context( const CONTEXT *context, data_size_t size )
 316 {
 317     CONTEXT ctx;
 318
 319     memset( &ctx, 0, sizeof(ctx) );
 320     memcpy( &ctx, context, min( size, sizeof(CONTEXT) ));
 321 #ifdef __i386__
 322     fprintf( stderr, "{flags=%08x,eax=%08x,ebx=%08x,ecx=%08x,edx=%08x,esi=%08x,edi=%08x,"
 323              "ebp=%08x,eip=%08x,esp=%08x,eflags=%08x,cs=%04x,ds=%04x,es=%04x,"
 324              "fs=%04x,gs=%04x,dr0=%08x,dr1=%08x,dr2=%08x,dr3=%08x,dr6=%08x,dr7=%08x,",
 325              ctx.ContextFlags, ctx.Eax, ctx.Ebx, ctx.Ecx, ctx.Edx,
 326              ctx.Esi, ctx.Edi, ctx.Ebp, ctx.Eip, ctx.Esp, ctx.EFlags,
 327              ctx.SegCs, ctx.SegDs, ctx.SegEs, ctx.SegFs, ctx.SegGs,
 328              ctx.Dr0, ctx.Dr1, ctx.Dr2, ctx.Dr3, ctx.Dr6, ctx.Dr7 );
 329     fprintf( stderr, "float=" );
 330     dump_uints( (const int *)&ctx.FloatSave, sizeof(ctx.FloatSave) / sizeof(int) );
 331     if (size > FIELD_OFFSET( CONTEXT, ExtendedRegisters ))
 332     {
 333         fprintf( stderr, ",extended=" );
 334         dump_uints( (const int *)&ctx.ExtendedRegisters, sizeof(ctx.ExtendedRegisters) / sizeof(int) );
 335     }
 336     fprintf( stderr, "}" );
 337 #else
 338     dump_uints( (const int *)&ctx, sizeof(ctx) / sizeof(int) );
 339 #endif
 340 }
 341
 342 static void dump_exc_record( const EXCEPTION_RECORD *rec )
 343 {
 344     unsigned int i;
 345     fprintf( stderr, "{code=%x,flags=%x,rec=%p,addr=%p,params={",
 346              rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionRecord,
 347              rec->ExceptionAddress );
 348     for (i = 0; i < min(rec->NumberParameters,EXCEPTION_MAXIMUM_PARAMETERS); i++)
 349     {
 350         if (i) fputc( ',', stderr );
 351         fprintf( stderr, "%lx", rec->ExceptionInformation[i] );
 352     }
 353     fputc( '}', stderr );
 354 }
 355
 356 static void dump_varargs_ints( data_size_t size )
 357 {
 358     const int *data = cur_data;
 359     data_size_t len = size / sizeof(*data);
 360
 361     fputc( '{', stderr );
 362     while (len > 0)
 363     {
 364         fprintf( stderr, "%d", *data++ );
 365         if (--len) fputc( ',', stderr );
 366     }
 367     fputc( '}', stderr );
 368     remove_data( size );
 369 }
 370
 371 static void dump_varargs_apc_result( data_size_t size )
 372 {
 373     const apc_result_t *result = cur_data;
 374
 375     if (size >= sizeof(*result))
 376     {
 377         dump_apc_result( result );
 378         size = sizeof(*result);
 379     }
 380     remove_data( size );
 381 }
 382
 383 static void dump_varargs_handles( data_size_t size )
 384 {
 385     const obj_handle_t *data = cur_data;
 386     data_size_t len = size / sizeof(*data);
 387
 388     fputc( '{', stderr );
 389     while (len > 0)
 390     {
 391         fprintf( stderr, "%04x", *data++ );
 392         if (--len) fputc( ',', stderr );
 393     }
 394     fputc( '}', stderr );
 395     remove_data( size );
 396 }
 397
 398 static void dump_varargs_user_handles( data_size_t size )
 399 {
 400     const user_handle_t *data = cur_data;
 401     data_size_t len = size / sizeof(*data);
 402
 403     fputc( '{', stderr );
 404     while (len > 0)
 405     {
 406         fprintf( stderr, "%08x", *data++ );
 407         if (--len) fputc( ',', stderr );
 408     }
 409     fputc( '}', stderr );
 410     remove_data( size );
 411 }
 412
 413 static void dump_varargs_bytes( data_size_t size )
 414 {
 415     const unsigned char *data = cur_data;
 416     data_size_t len = size;
 417
 418     fputc( '{', stderr );
 419     while (len > 0)
 420     {
 421         fprintf( stderr, "%02x", *data++ );
 422         if (--len) fputc( ',', stderr );
 423     }
 424     fputc( '}', stderr );
 425     remove_data( size );
 426 }
 427
 428 static void dump_varargs_string( data_size_t size )
 429 {
 430     fprintf( stderr, "\"%.*s\"", (int)size, (const char *)cur_data );
 431     remove_data( size );
 432 }
 433
 434 static void dump_varargs_unicode_str( data_size_t size )
 435 {
 436     fprintf( stderr, "L\"" );
 437     dump_strW( cur_data, size / sizeof(WCHAR), stderr, "\"\"" );
 438     fputc( '\"', stderr );
 439     remove_data( size );
 440 }
 441
 442 static void dump_varargs_context( data_size_t size )
 443 {
 444     if (!size)
 445     {
 446         fprintf( stderr, "{}" );
 447         return;
 448     }
 449     dump_context( cur_data, size );
 450     remove_data( min( size, sizeof(CONTEXT) ));
 451 }
 452
 453 static void dump_varargs_exc_event( data_size_t size )
 454 {
 455     const CONTEXT *ptr = cur_data;
 456
 457     if (!size)
 458     {
 459         fprintf( stderr, "{}" );
 460         return;
 461     }
 462     fprintf( stderr, "{context=" );
 463     dump_context( ptr, size );
 464     if (size > sizeof(CONTEXT))
 465     {
 466         fprintf( stderr, ",rec=" );
 467         dump_exc_record( (const EXCEPTION_RECORD *)(ptr + 1) );
 468     }
 469     fputc( '}', stderr );
 470     remove_data( size );
 471 }
 472
 473 static void dump_varargs_debug_event( data_size_t size )
 474 {
 475     const debug_event_t *event = cur_data;
 476
 477     if (!size)
 478     {
 479         fprintf( stderr, "{}" );
 480         return;
 481     }
 482     switch(event->code)
 483     {
 484     case EXCEPTION_DEBUG_EVENT:
 485         fprintf( stderr, "{exception," );
 486         dump_exc_record( &event->info.exception.record );
 487         fprintf( stderr, ",first=%d}", event->info.exception.first );
 488         break;
 489     case CREATE_THREAD_DEBUG_EVENT:
 490         fprintf( stderr, "{create_thread,thread=%04x,teb=%p,start=%p}",
 491                  event->info.create_thread.handle, event->info.create_thread.teb,
 492                  event->info.create_thread.start );
 493         break;
 494     case CREATE_PROCESS_DEBUG_EVENT:
 495         fprintf( stderr, "{create_process,file=%04x,process=%04x,thread=%04x,base=",
 496                  event->info.create_process.file, event->info.create_process.process,
 497                  event->info.create_process.thread );
 498         dump_uint64( &event->info.create_process.base );
 499         fprintf( stderr, ",offset=%d,size=%d,teb=%p,start=%p,name=",
 500                  event->info.create_process.dbg_offset, event->info.create_process.dbg_size,
 501                  event->info.create_process.teb, event->info.create_process.start );
 502         dump_uint64( &event->info.create_process.name );
 503         fprintf( stderr, ",unicode=%d}", event->info.create_process.unicode );
 504         break;
 505     case EXIT_THREAD_DEBUG_EVENT:
 506         fprintf( stderr, "{exit_thread,code=%d}", event->info.exit.exit_code );
 507         break;
 508     case EXIT_PROCESS_DEBUG_EVENT:
 509         fprintf( stderr, "{exit_process,code=%d}", event->info.exit.exit_code );
 510         break;
 511     case LOAD_DLL_DEBUG_EVENT:
 512         fprintf( stderr, "{load_dll,file=%04x,base", event->info.load_dll.handle );
 513         dump_uint64( &event->info.load_dll.base );
 514         fprintf( stderr, ",offset=%d,size=%d,name=",
 515                  event->info.load_dll.dbg_offset, event->info.load_dll.dbg_size );
 516         dump_uint64( &event->info.load_dll.name );
 517         fprintf( stderr, ",unicode=%d}", event->info.load_dll.unicode );
 518         break;
 519     case UNLOAD_DLL_DEBUG_EVENT:
 520         fputs( "{unload_dll,base=", stderr );
 521         dump_uint64( &event->info.unload_dll.base );
 522         fputc( '}', stderr );
 523         break;
 524     case OUTPUT_DEBUG_STRING_EVENT:
 525         fprintf( stderr, "{output_string,string=" );
 526         dump_uint64( &event->info.output_string.string );
 527         fprintf( stderr, ",unicode=%d,len=%u}",
 528                  event->info.output_string.unicode, event->info.output_string.length );
 529         break;
 530     case RIP_EVENT:
 531         fprintf( stderr, "{rip,err=%d,type=%d}",
 532                  event->info.rip_info.error, event->info.rip_info.type );
 533         break;
 534     case 0:  /* zero is the code returned on timeouts */
 535         fprintf( stderr, "{}" );
 536         break;
 537     default:
 538         fprintf( stderr, "{code=??? (%d)}", event->code );
 539         break;
 540     }
 541     remove_data( size );
 542 }
 543
 544 /* dump a unicode string contained in a buffer; helper for dump_varargs_startup_info */
 545 static void dump_inline_unicode_string( const UNICODE_STRING *str, const void *data, data_size_t size )
 546 {
 547     size_t length = str->Length;
 548     size_t offset = (size_t)str->Buffer;
 549
 550     if (offset >= size) return;
 551     if (offset + length > size) length = size - offset;
 552     dump_strW( (const WCHAR *)data + offset/sizeof(WCHAR), length/sizeof(WCHAR), stderr, "\"\"" );
 553 }
 554
 555 static void dump_varargs_startup_info( data_size_t size )
 556 {
 557     const RTL_USER_PROCESS_PARAMETERS *ptr = cur_data;
 558     RTL_USER_PROCESS_PARAMETERS params;
 559
 560     if (size < sizeof(params.Size))
 561     {
 562         fprintf( stderr, "{}" );
 563         return;
 564     }
 565     if (size > ptr->Size) size = ptr->Size;
 566     memset( &params, 0, sizeof(params) );
 567     memcpy( &params, ptr, min( size, sizeof(params) ));
 568
 569     fprintf( stderr, "{AllocationSize=%x,", params.AllocationSize );
 570     fprintf( stderr, "Size=%x,", params.Size );
 571     fprintf( stderr, "Flags=%x,", params.Flags );
 572     fprintf( stderr, "DebugFlags=%x,", params.DebugFlags );
 573     fprintf( stderr, "ConsoleHandle=%p,", params.ConsoleHandle );
 574     fprintf( stderr, "ConsoleFlags=%x,", params.ConsoleFlags );
 575     fprintf( stderr, "hStdInput=%p,", params.hStdInput );
 576     fprintf( stderr, "hStdOutput=%p,", params.hStdOutput );
 577     fprintf( stderr, "hStdError=%p,", params.hStdError );
 578     fprintf( stderr, "CurrentDirectory.Handle=%p,", params.CurrentDirectory.Handle );
 579     fprintf( stderr, "dwX=%d,", params.dwX );
 580     fprintf( stderr, "dwY=%d,", params.dwY );
 581     fprintf( stderr, "dwXSize=%d,", params.dwXSize );
 582     fprintf( stderr, "dwYSize=%d,", params.dwYSize );
 583     fprintf( stderr, "dwXCountChars=%d,", params.dwXCountChars );
 584     fprintf( stderr, "dwYCountChars=%d,", params.dwYCountChars );
 585     fprintf( stderr, "dwFillAttribute=%x,", params.dwFillAttribute );
 586     fprintf( stderr, "dwFlags=%x,", params.dwFlags );
 587     fprintf( stderr, "wShowWindow=%x,", params.wShowWindow );
 588     fprintf( stderr, "CurrentDirectory.DosPath=L\"" );
 589     dump_inline_unicode_string( &params.CurrentDirectory.DosPath, cur_data, size );
 590     fprintf( stderr, "\",DllPath=L\"" );
 591     dump_inline_unicode_string( &params.DllPath, cur_data, size );
 592     fprintf( stderr, "\",ImagePathName=L\"" );
 593     dump_inline_unicode_string( &params.ImagePathName, cur_data, size );
 594     fprintf( stderr, "\",CommandLine=L\"" );
 595     dump_inline_unicode_string( &params.CommandLine, cur_data, size );
 596     fprintf( stderr, "\",WindowTitle=L\"" );
 597     dump_inline_unicode_string( &params.WindowTitle, cur_data, size );
 598     fprintf( stderr, "\",Desktop=L\"" );
 599     dump_inline_unicode_string( &params.Desktop, cur_data, size );
 600     fprintf( stderr, "\",ShellInfo=L\"" );
 601     dump_inline_unicode_string( &params.ShellInfo, cur_data, size );
 602     fprintf( stderr, "\",RuntimeInfo=L\"" );
 603     dump_inline_unicode_string( &params.RuntimeInfo, cur_data, size );
 604     fprintf( stderr, "\"}" );
 605     remove_data( size );
 606 }
 607
 608 static void dump_varargs_input_records( data_size_t size )
 609 {
 610     const INPUT_RECORD *rec = cur_data;
 611     data_size_t len = size / sizeof(*rec);
 612
 613     fputc( '{', stderr );
 614     while (len > 0)
 615     {
 616         fprintf( stderr, "{%04x,...}", rec->EventType );
 617         rec++;
 618         if (--len) fputc( ',', stderr );
 619     }
 620     fputc( '}', stderr );
 621     remove_data( size );
 622 }
 623
 624 static void dump_varargs_rectangles( data_size_t size )
 625 {
 626     const rectangle_t *rect = cur_data;
 627     data_size_t len = size / sizeof(*rect);
 628
 629     fputc( '{', stderr );
 630     while (len > 0)
 631     {
 632         dump_rectangle( rect++ );
 633         if (--len) fputc( ',', stderr );
 634     }
 635     fputc( '}', stderr );
 636     remove_data( size );
 637 }
 638
 639 static void dump_varargs_message_data( data_size_t size )
 640 {
 641     /* FIXME: dump the structured data */
 642     dump_varargs_bytes( size );
 643 }
 644
 645 static void dump_varargs_properties( data_size_t size )
 646 {
 647     const property_data_t *prop = cur_data;
 648     data_size_t len = size / sizeof(*prop);
 649
 650     fputc( '{', stderr );
 651     while (len > 0)
 652     {
 653         fprintf( stderr, "{atom=%04x,str=%d,data=", prop->atom, prop->string );
 654         dump_uint64( &prop->data );
 655         fputc( '}', stderr );
 656         prop++;
 657         if (--len) fputc( ',', stderr );
 658     }
 659     fputc( '}', stderr );
 660     remove_data( size );
 661 }
 662
 663 static void dump_varargs_LUID_AND_ATTRIBUTES( data_size_t size )
 664 {
 665     const LUID_AND_ATTRIBUTES *lat = cur_data;
 666     data_size_t len = size / sizeof(*lat);
 667
 668     fputc( '{', stderr );
 669     while (len > 0)
 670     {
 671         fprintf( stderr, "{luid=%08x%08x,attr=%x}",
 672                  lat->Luid.HighPart, lat->Luid.LowPart, lat->Attributes );
 673         lat++;
 674         if (--len) fputc( ',', stderr );
 675     }
 676     fputc( '}', stderr );
 677     remove_data( size );
 678 }
 679
 680 static void dump_inline_sid( const SID *sid, data_size_t size )
 681 {
 682     DWORD i;
 683
 684     /* security check */
 685     if ((FIELD_OFFSET(SID, SubAuthority[0]) > size) ||
 686         (FIELD_OFFSET(SID, SubAuthority[sid->SubAuthorityCount]) > size))
 687     {
 688         fprintf( stderr, "<invalid sid>" );
 689         return;
 690     }
 691
 692     fputc( '{', stderr );
 693     fprintf( stderr, "S-%u-%u", sid->Revision, MAKELONG(
 694         MAKEWORD( sid->IdentifierAuthority.Value[5],
 695                   sid->IdentifierAuthority.Value[4] ),
 696         MAKEWORD( sid->IdentifierAuthority.Value[3],
 697                   sid->IdentifierAuthority.Value[2] ) ) );
 698     for (i = 0; i < sid->SubAuthorityCount; i++)
 699         fprintf( stderr, "-%u", sid->SubAuthority[i] );
 700     fputc( '}', stderr );
 701 }
 702
 703 static void dump_varargs_SID( data_size_t size )
 704 {
 705     const SID *sid = cur_data;
 706     dump_inline_sid( sid, size );
 707     remove_data( size );
 708 }
 709
 710 static void dump_inline_acl( const ACL *acl, data_size_t size )
 711 {
 712     const ACE_HEADER *ace;
 713     ULONG i;
 714     fputc( '{', stderr );
 715
 716     if (size)
 717     {
 718         if (size < sizeof(ACL))
 719         {
 720             fprintf( stderr, "<invalid acl>}\n" );
 721             return;
 722         }
 723         size -= sizeof(ACL);
 724         ace = (const ACE_HEADER *)(acl + 1);
 725         for (i = 0; i < acl->AceCount; i++)
 726         {
 727             const SID *sid = NULL;
 728             data_size_t sid_size = 0;
 729
 730             if (size < sizeof(ACE_HEADER))
 731                 return;
 732             if (size < ace->AceSize)
 733                 return;
 734             size -= ace->AceSize;
 735             if (i != 0) fputc( ',', stderr );
 736             fprintf( stderr, "{AceType=" );
 737             switch (ace->AceType)
 738             {
 739             case ACCESS_DENIED_ACE_TYPE:
 740                 sid = (const SID *)&((const ACCESS_DENIED_ACE *)ace)->SidStart;
 741                 sid_size = ace->AceSize - FIELD_OFFSET(ACCESS_DENIED_ACE, SidStart);
 742                 fprintf( stderr, "ACCESS_DENIED_ACE_TYPE,Mask=%x",
 743                          ((const ACCESS_DENIED_ACE *)ace)->Mask );
 744                 break;
 745             case ACCESS_ALLOWED_ACE_TYPE:
 746                 sid = (const SID *)&((const ACCESS_ALLOWED_ACE *)ace)->SidStart;
 747                 sid_size = ace->AceSize - FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart);
 748                 fprintf( stderr, "ACCESS_ALLOWED_ACE_TYPE,Mask=%x",
 749                          ((const ACCESS_ALLOWED_ACE *)ace)->Mask );
 750                 break;
 751             case SYSTEM_AUDIT_ACE_TYPE:
 752                 sid = (const SID *)&((const SYSTEM_AUDIT_ACE *)ace)->SidStart;
 753                 sid_size = ace->AceSize - FIELD_OFFSET(SYSTEM_AUDIT_ACE, SidStart);
 754                 fprintf( stderr, "SYSTEM_AUDIT_ACE_TYPE,Mask=%x",
 755                          ((const SYSTEM_AUDIT_ACE *)ace)->Mask );
 756                 break;
 757             case SYSTEM_ALARM_ACE_TYPE:
 758                 sid = (const SID *)&((const SYSTEM_ALARM_ACE *)ace)->SidStart;
 759                 sid_size = ace->AceSize - FIELD_OFFSET(SYSTEM_ALARM_ACE, SidStart);
 760                 fprintf( stderr, "SYSTEM_ALARM_ACE_TYPE,Mask=%x",
 761                          ((const SYSTEM_ALARM_ACE *)ace)->Mask );
 762                 break;
 763             default:
 764                 fprintf( stderr, "unknown<%d>", ace->AceType );
 765                 break;
 766             }
 767             fprintf( stderr, ",AceFlags=%x,Sid=", ace->AceFlags );
 768             if (sid)
 769                 dump_inline_sid( sid, sid_size );
 770             ace = (const ACE_HEADER *)((const char *)ace + ace->AceSize);
 771             fputc( '}', stderr );
 772         }
 773     }
 774     fputc( '}', stderr );
 775 }
 776
 777 static void dump_inline_security_descriptor( const struct security_descriptor *sd, data_size_t size )
 778 {
 779     fputc( '{', stderr );
 780     if (size >= sizeof(struct security_descriptor))
 781     {
 782         size_t offset = sizeof(struct security_descriptor);
 783         fprintf( stderr, "control=%08x", sd->control );
 784         fprintf( stderr, ",owner=" );
 785         if ((sd->owner_len > FIELD_OFFSET(SID, SubAuthority[255])) || (offset + sd->owner_len > size))
 786             return;
 787         if (sd->owner_len)
 788             dump_inline_sid( (const SID *)((const char *)sd + offset), sd->owner_len );
 789         else
 790             fprintf( stderr, "<not present>" );
 791         offset += sd->owner_len;
 792         fprintf( stderr, ",group=" );
 793         if ((sd->group_len > FIELD_OFFSET(SID, SubAuthority[255])) || (offset + sd->group_len > size))
 794             return;
 795         if (sd->group_len)
 796             dump_inline_sid( (const SID *)((const char *)sd + offset), sd->group_len );
 797         else
 798             fprintf( stderr, "<not present>" );
 799         offset += sd->group_len;
 800         fprintf( stderr, ",sacl=" );
 801         if ((sd->sacl_len >= MAX_ACL_LEN) || (offset + sd->sacl_len > size))
 802             return;
 803         dump_inline_acl( (const ACL *)((const char *)sd + offset), sd->sacl_len );
 804         offset += sd->sacl_len;
 805         fprintf( stderr, ",dacl=" );
 806         if ((sd->dacl_len >= MAX_ACL_LEN) || (offset + sd->dacl_len > size))
 807             return;
 808         dump_inline_acl( (const ACL *)((const char *)sd + offset), sd->dacl_len );
 809         offset += sd->dacl_len;
 810     }
 811     fputc( '}', stderr );
 812 }
 813
 814 static void dump_varargs_security_descriptor( data_size_t size )
 815 {
 816     const struct security_descriptor *sd = cur_data;
 817     dump_inline_security_descriptor( sd, size );
 818     remove_data( size );
 819 }
 820
 821 static void dump_varargs_token_groups( data_size_t size )
 822 {
 823     const struct token_groups *tg = cur_data;
 824     fputc( '{', stderr );
 825     if (size >= sizeof(struct token_groups))
 826     {
 827         size_t offset = sizeof(*tg);
 828         fprintf( stderr, "count=%08x,", tg->count );
 829         if (tg->count * sizeof(unsigned int) <= size)
 830         {
 831             unsigned int i;
 832             const unsigned int *attr = (const unsigned int *)(tg + 1);
 833
 834             offset += tg->count * sizeof(unsigned int);
 835
 836             fputc( '[', stderr );
 837             for (i = 0; i < tg->count; i++)
 838             {
 839                 const SID *sid = (const SID *)((const char *)cur_data + offset);
 840                 if (i != 0)
 841                     fputc( ',', stderr );
 842                 fputc( '{', stderr );
 843                 fprintf( stderr, "attributes=%08x", attr[i] );
 844                 fprintf( stderr, ",sid=" );
 845                 dump_inline_sid( sid, size - offset );
 846                 if ((offset + FIELD_OFFSET(SID, SubAuthority[0]) > size) ||
 847                     (offset + FIELD_OFFSET(SID, SubAuthority[sid->SubAuthorityCount]) > size))
 848                     break;
 849                 offset += FIELD_OFFSET(SID, SubAuthority[sid->SubAuthorityCount]);
 850                 fputc( '}', stderr );
 851             }
 852             fputc( ']', stderr );
 853         }
 854     }
 855     fputc( '}', stderr );
 856 }
 857
 858 static void dump_varargs_object_attributes( data_size_t size )
 859 {
 860     const struct object_attributes *objattr = cur_data;
 861     fputc( '{', stderr );
 862     if (size >= sizeof(struct object_attributes))
 863     {
 864         const WCHAR *str;
 865         fprintf( stderr, "rootdir=%04x,sd=", objattr->rootdir );
 866         if (objattr->sd_len > size - sizeof(*objattr) ||
 867             objattr->name_len > size - sizeof(*objattr) - objattr->sd_len)
 868             return;
 869         dump_inline_security_descriptor( (const struct security_descriptor *)(objattr + 1), objattr->sd_len );
 870         str = (const WCHAR *)objattr + (sizeof(*objattr) + objattr->sd_len) / sizeof(WCHAR);
 871         fprintf( stderr, ",name=L\"" );
 872         dump_strW( str, objattr->name_len / sizeof(WCHAR), stderr, "\"\"" );
 873         fputc( '\"', stderr );
 874         remove_data( ((sizeof(*objattr) + objattr->sd_len) / sizeof(WCHAR)) * sizeof(WCHAR) +
 875                      objattr->name_len );
 876     }
 877     fputc( '}', stderr );
 878 }
 879
 880 typedef void (*dump_func)( const void *req );
 881
 882 /* Everything below this line is generated automatically by tools/make_requests */
 883 /* ### make_requests begin ### */
 884
 885 static void dump_new_process_request( const struct new_process_request *req )
 886 {
 887     fprintf( stderr, " inherit_all=%d,", req->inherit_all );
 888     fprintf( stderr, " create_flags=%08x,", req->create_flags );
 889     fprintf( stderr, " socket_fd=%d,", req->socket_fd );
 890     fprintf( stderr, " exe_file=%04x,", req->exe_file );
 891     fprintf( stderr, " hstdin=%04x,", req->hstdin );
 892     fprintf( stderr, " hstdout=%04x,", req->hstdout );
 893     fprintf( stderr, " hstderr=%04x,", req->hstderr );
 894     fprintf( stderr, " process_access=%08x,", req->process_access );
 895     fprintf( stderr, " process_attr=%08x,", req->process_attr );
 896     fprintf( stderr, " thread_access=%08x,", req->thread_access );
 897     fprintf( stderr, " thread_attr=%08x,", req->thread_attr );
 898     fprintf( stderr, " info=" );
 899     dump_varargs_startup_info( cur_size );
 900     fputc( ',', stderr );
 901     fprintf( stderr, " env=" );
 902     dump_varargs_unicode_str( cur_size );
 903 }
 904
 905 static void dump_new_process_reply( const struct new_process_reply *req )
 906 {
 907     fprintf( stderr, " info=%04x,", req->info );
 908     fprintf( stderr, " pid=%04x,", req->pid );
 909     fprintf( stderr, " phandle=%04x,", req->phandle );
 910     fprintf( stderr, " tid=%04x,", req->tid );
 911     fprintf( stderr, " thandle=%04x", req->thandle );
 912 }
 913
 914 static void dump_get_new_process_info_request( const struct get_new_process_info_request *req )
 915 {
 916     fprintf( stderr, " info=%04x", req->info );
 917 }
 918
 919 static void dump_get_new_process_info_reply( const struct get_new_process_info_reply *req )
 920 {
 921     fprintf( stderr, " success=%d,", req->success );
 922     fprintf( stderr, " exit_code=%d", req->exit_code );
 923 }
 924
 925 static void dump_new_thread_request( const struct new_thread_request *req )
 926 {
 927     fprintf( stderr, " access=%08x,", req->access );
 928     fprintf( stderr, " attributes=%08x,", req->attributes );
 929     fprintf( stderr, " suspend=%d,", req->suspend );
 930     fprintf( stderr, " request_fd=%d", req->request_fd );
 931 }
 932
 933 static void dump_new_thread_reply( const struct new_thread_reply *req )
 934 {
 935     fprintf( stderr, " tid=%04x,", req->tid );
 936     fprintf( stderr, " handle=%04x", req->handle );
 937 }
 938
 939 static void dump_get_startup_info_request( const struct get_startup_info_request *req )
 940 {
 941 }
 942
 943 static void dump_get_startup_info_reply( const struct get_startup_info_reply *req )
 944 {
 945     fprintf( stderr, " exe_file=%04x,", req->exe_file );
 946     fprintf( stderr, " hstdin=%04x,", req->hstdin );
 947     fprintf( stderr, " hstdout=%04x,", req->hstdout );
 948     fprintf( stderr, " hstderr=%04x,", req->hstderr );
 949     fprintf( stderr, " info=" );
 950     dump_varargs_startup_info( cur_size );
 951     fputc( ',', stderr );
 952     fprintf( stderr, " env=" );
 953     dump_varargs_unicode_str( cur_size );
 954 }
 955
 956 static void dump_init_process_done_request( const struct init_process_done_request *req )
 957 {
 958     fprintf( stderr, " gui=%d,", req->gui );
 959     fprintf( stderr, " module=" );
 960     dump_uint64( &req->module );
 961     fprintf( stderr, "," );
 962     fprintf( stderr, " entry=%p", req->entry );
 963 }
 964
 965 static void dump_init_thread_request( const struct init_thread_request *req )
 966 {
 967     fprintf( stderr, " unix_pid=%d,", req->unix_pid );
 968     fprintf( stderr, " unix_tid=%d,", req->unix_tid );
 969     fprintf( stderr, " debug_level=%d,", req->debug_level );
 970     fprintf( stderr, " teb=%p,", req->teb );
 971     fprintf( stderr, " peb=%p,", req->peb );
 972     fprintf( stderr, " entry=%p,", req->entry );
 973     fprintf( stderr, " ldt_copy=%p,", req->ldt_copy );
 974     fprintf( stderr, " reply_fd=%d,", req->reply_fd );
 975     fprintf( stderr, " wait_fd=%d", req->wait_fd );
 976 }
 977
 978 static void dump_init_thread_reply( const struct init_thread_reply *req )
 979 {
 980     fprintf( stderr, " pid=%04x,", req->pid );
 981     fprintf( stderr, " tid=%04x,", req->tid );
 982     fprintf( stderr, " info_size=%u,", req->info_size );
 983     fprintf( stderr, " server_start=" );
 984     dump_timeout( &req->server_start );
 985     fprintf( stderr, "," );
 986     fprintf( stderr, " version=%d", req->version );
 987 }
 988
 989 static void dump_terminate_process_request( const struct terminate_process_request *req )
 990 {
 991     fprintf( stderr, " handle=%04x,", req->handle );
 992     fprintf( stderr, " exit_code=%d", req->exit_code );
 993 }
 994
 995 static void dump_terminate_process_reply( const struct terminate_process_reply *req )
 996 {
 997     fprintf( stderr, " self=%d", req->self );
 998 }
 999
1000 static void dump_terminate_thread_request( const struct terminate_thread_request *req )
1001 {
1002     fprintf( stderr, " handle=%04x,", req->handle );
1003     fprintf( stderr, " exit_code=%d", req->exit_code );
1004 }
1005
1006 static void dump_terminate_thread_reply( const struct terminate_thread_reply *req )
1007 {
1008     fprintf( stderr, " self=%d,", req->self );
1009     fprintf( stderr, " last=%d", req->last );
1010 }
1011
1012 static void dump_get_process_info_request( const struct get_process_info_request *req )
1013 {
1014     fprintf( stderr, " handle=%04x", req->handle );
1015 }
1016
1017 static void dump_get_process_info_reply( const struct get_process_info_reply *req )
1018 {
1019     fprintf( stderr, " pid=%04x,", req->pid );
1020     fprintf( stderr, " ppid=%04x,", req->ppid );
1021     fprintf( stderr, " exit_code=%d,", req->exit_code );
1022     fprintf( stderr, " priority=%d,", req->priority );
1023     fprintf( stderr, " affinity=%08x,", req->affinity );
1024     fprintf( stderr, " peb=%p,", req->peb );
1025     fprintf( stderr, " start_time=" );
1026     dump_timeout( &req->start_time );
1027     fprintf( stderr, "," );
1028     fprintf( stderr, " end_time=" );
1029     dump_timeout( &req->end_time );
1030 }
1031
1032 static void dump_set_process_info_request( const struct set_process_info_request *req )
1033 {
1034     fprintf( stderr, " handle=%04x,", req->handle );
1035     fprintf( stderr, " mask=%d,", req->mask );
1036     fprintf( stderr, " priority=%d,", req->priority );
1037     fprintf( stderr, " affinity=%08x", req->affinity );
1038 }
1039
1040 static void dump_get_thread_info_request( const struct get_thread_info_request *req )
1041 {
1042     fprintf( stderr, " handle=%04x,", req->handle );
1043     fprintf( stderr, " tid_in=%04x", req->tid_in );
1044 }
1045
1046 static void dump_get_thread_info_reply( const struct get_thread_info_reply *req )
1047 {
1048     fprintf( stderr, " pid=%04x,", req->pid );
1049     fprintf( stderr, " tid=%04x,", req->tid );
1050     fprintf( stderr, " teb=%p,", req->teb );
1051     fprintf( stderr, " exit_code=%d,", req->exit_code );
1052     fprintf( stderr, " priority=%d,", req->priority );
1053     fprintf( stderr, " affinity=%08x,", req->affinity );
1054     fprintf( stderr, " creation_time=" );
1055     dump_timeout( &req->creation_time );
1056     fprintf( stderr, "," );
1057     fprintf( stderr, " exit_time=" );
1058     dump_timeout( &req->exit_time );
1059     fprintf( stderr, "," );
1060     fprintf( stderr, " last=%d", req->last );
1061 }
1062
1063 static void dump_set_thread_info_request( const struct set_thread_info_request *req )
1064 {
1065     fprintf( stderr, " handle=%04x,", req->handle );
1066     fprintf( stderr, " mask=%d,", req->mask );
1067     fprintf( stderr, " priority=%d,", req->priority );
1068     fprintf( stderr, " affinity=%08x,", req->affinity );
1069     fprintf( stderr, " token=%04x", req->token );
1070 }
1071
1072 static void dump_get_dll_info_request( const struct get_dll_info_request *req )
1073 {
1074     fprintf( stderr, " handle=%04x,", req->handle );
1075     fprintf( stderr, " base_address=" );
1076     dump_uint64( &req->base_address );
1077 }
1078
1079 static void dump_get_dll_info_reply( const struct get_dll_info_reply *req )
1080 {
1081     fprintf( stderr, " entry_point=%p,", req->entry_point );
1082     fprintf( stderr, " size=%u,", req->size );
1083     fprintf( stderr, " filename_len=%u,", req->filename_len );
1084     fprintf( stderr, " filename=" );
1085     dump_varargs_unicode_str( cur_size );
1086 }
1087
1088 static void dump_suspend_thread_request( const struct suspend_thread_request *req )
1089 {
1090     fprintf( stderr, " handle=%04x", req->handle );
1091 }
1092
1093 static void dump_suspend_thread_reply( const struct suspend_thread_reply *req )
1094 {
1095     fprintf( stderr, " count=%d", req->count );
1096 }
1097
1098 static void dump_resume_thread_request( const struct resume_thread_request *req )
1099 {
1100     fprintf( stderr, " handle=%04x", req->handle );
1101 }
1102
1103 static void dump_resume_thread_reply( const struct resume_thread_reply *req )
1104 {
1105     fprintf( stderr, " count=%d", req->count );
1106 }
1107
1108 static void dump_load_dll_request( const struct load_dll_request *req )
1109 {
1110     fprintf( stderr, " handle=%04x,", req->handle );
1111     fprintf( stderr, " base=" );
1112     dump_uint64( &req->base );
1113     fprintf( stderr, "," );
1114     fprintf( stderr, " name=" );
1115     dump_uint64( &req->name );
1116     fprintf( stderr, "," );
1117     fprintf( stderr, " size=%u,", req->size );
1118     fprintf( stderr, " dbg_offset=%d,", req->dbg_offset );
1119     fprintf( stderr, " dbg_size=%d,", req->dbg_size );
1120     fprintf( stderr, " filename=" );
1121     dump_varargs_unicode_str( cur_size );
1122 }
1123
1124 static void dump_unload_dll_request( const struct unload_dll_request *req )
1125 {
1126     fprintf( stderr, " base=" );
1127     dump_uint64( &req->base );
1128 }
1129
1130 static void dump_queue_apc_request( const struct queue_apc_request *req )
1131 {
1132     fprintf( stderr, " handle=%04x,", req->handle );
1133     fprintf( stderr, " call=" );
1134     dump_apc_call( &req->call );
1135 }
1136
1137 static void dump_queue_apc_reply( const struct queue_apc_reply *req )
1138 {
1139     fprintf( stderr, " handle=%04x,", req->handle );
1140     fprintf( stderr, " self=%d", req->self );
1141 }
1142
1143 static void dump_get_apc_result_request( const struct get_apc_result_request *req )
1144 {
1145     fprintf( stderr, " handle=%04x", req->handle );
1146 }
1147
1148 static void dump_get_apc_result_reply( const struct get_apc_result_reply *req )
1149 {
1150     fprintf( stderr, " result=" );
1151     dump_apc_result( &req->result );
1152 }
1153
1154 static void dump_close_handle_request( const struct close_handle_request *req )
1155 {
1156     fprintf( stderr, " handle=%04x", req->handle );
1157 }
1158
1159 static void dump_set_handle_info_request( const struct set_handle_info_request *req )
1160 {
1161     fprintf( stderr, " handle=%04x,", req->handle );
1162     fprintf( stderr, " flags=%d,", req->flags );
1163     fprintf( stderr, " mask=%d", req->mask );
1164 }
1165
1166 static void dump_set_handle_info_reply( const struct set_handle_info_reply *req )
1167 {
1168     fprintf( stderr, " old_flags=%d", req->old_flags );
1169 }
1170
1171 static void dump_dup_handle_request( const struct dup_handle_request *req )
1172 {
1173     fprintf( stderr, " src_process=%04x,", req->src_process );
1174     fprintf( stderr, " src_handle=%04x,", req->src_handle );
1175     fprintf( stderr, " dst_process=%04x,", req->dst_process );
1176     fprintf( stderr, " access=%08x,", req->access );
1177     fprintf( stderr, " attributes=%08x,", req->attributes );
1178     fprintf( stderr, " options=%08x", req->options );
1179 }
1180
1181 static void dump_dup_handle_reply( const struct dup_handle_reply *req )
1182 {
1183     fprintf( stderr, " handle=%04x,", req->handle );
1184     fprintf( stderr, " self=%d,", req->self );
1185     fprintf( stderr, " closed=%d", req->closed );
1186 }
1187
1188 static void dump_open_process_request( const struct open_process_request *req )
1189 {
1190     fprintf( stderr, " pid=%04x,", req->pid );
1191     fprintf( stderr, " access=%08x,", req->access );
1192     fprintf( stderr, " attributes=%08x", req->attributes );
1193 }
1194
1195 static void dump_open_process_reply( const struct open_process_reply *req )
1196 {
1197     fprintf( stderr, " handle=%04x", req->handle );
1198 }
1199
1200 static void dump_open_thread_request( const struct open_thread_request *req )
1201 {
1202     fprintf( stderr, " tid=%04x,", req->tid );
1203     fprintf( stderr, " access=%08x,", req->access );
1204     fprintf( stderr, " attributes=%08x", req->attributes );
1205 }
1206
1207 static void dump_open_thread_reply( const struct open_thread_reply *req )
1208 {
1209     fprintf( stderr, " handle=%04x", req->handle );
1210 }
1211
1212 static void dump_select_request( const struct select_request *req )
1213 {
1214     fprintf( stderr, " flags=%d,", req->flags );
1215     fprintf( stderr, " cookie=" );
1216     dump_uint64( &req->cookie );
1217     fprintf( stderr, "," );
1218     fprintf( stderr, " signal=%04x,", req->signal );
1219     fprintf( stderr, " prev_apc=%04x,", req->prev_apc );
1220     fprintf( stderr, " timeout=" );
1221     dump_timeout( &req->timeout );
1222     fprintf( stderr, "," );
1223     fprintf( stderr, " result=" );
1224     dump_varargs_apc_result( cur_size );
1225     fputc( ',', stderr );
1226     fprintf( stderr, " handles=" );
1227     dump_varargs_handles( cur_size );
1228 }
1229
1230 static void dump_select_reply( const struct select_reply *req )
1231 {
1232     fprintf( stderr, " timeout=" );
1233     dump_timeout( &req->timeout );
1234     fprintf( stderr, "," );
1235     fprintf( stderr, " call=" );
1236     dump_apc_call( &req->call );
1237     fprintf( stderr, "," );
1238     fprintf( stderr, " apc_handle=%04x", req->apc_handle );
1239 }
1240
1241 static void dump_create_event_request( const struct create_event_request *req )
1242 {
1243     fprintf( stderr, " access=%08x,", req->access );
1244     fprintf( stderr, " attributes=%08x,", req->attributes );
1245     fprintf( stderr, " manual_reset=%d,", req->manual_reset );
1246     fprintf( stderr, " initial_state=%d,", req->initial_state );
1247     fprintf( stderr, " objattr=" );
1248     dump_varargs_object_attributes( cur_size );
1249 }
1250
1251 static void dump_create_event_reply( const struct create_event_reply *req )
1252 {
1253     fprintf( stderr, " handle=%04x", req->handle );
1254 }
1255
1256 static void dump_event_op_request( const struct event_op_request *req )
1257 {
1258     fprintf( stderr, " handle=%04x,", req->handle );
1259     fprintf( stderr, " op=%d", req->op );
1260 }
1261
1262 static void dump_open_event_request( const struct open_event_request *req )
1263 {
1264     fprintf( stderr, " access=%08x,", req->access );
1265     fprintf( stderr, " attributes=%08x,", req->attributes );
1266     fprintf( stderr, " rootdir=%04x,", req->rootdir );
1267     fprintf( stderr, " name=" );
1268     dump_varargs_unicode_str( cur_size );
1269 }
1270
1271 static void dump_open_event_reply( const struct open_event_reply *req )
1272 {
1273     fprintf( stderr, " handle=%04x", req->handle );
1274 }
1275
1276 static void dump_create_mutex_request( const struct create_mutex_request *req )
1277 {
1278     fprintf( stderr, " access=%08x,", req->access );
1279     fprintf( stderr, " attributes=%08x,", req->attributes );
1280     fprintf( stderr, " owned=%d,", req->owned );
1281     fprintf( stderr, " objattr=" );
1282     dump_varargs_object_attributes( cur_size );
1283 }
1284
1285 static void dump_create_mutex_reply( const struct create_mutex_reply *req )
1286 {
1287     fprintf( stderr, " handle=%04x", req->handle );
1288 }
1289
1290 static void dump_release_mutex_request( const struct release_mutex_request *req )
1291 {
1292     fprintf( stderr, " handle=%04x", req->handle );
1293 }
1294
1295 static void dump_release_mutex_reply( const struct release_mutex_reply *req )
1296 {
1297     fprintf( stderr, " prev_count=%08x", req->prev_count );
1298 }
1299
1300 static void dump_open_mutex_request( const struct open_mutex_request *req )
1301 {
1302     fprintf( stderr, " access=%08x,", req->access );
1303     fprintf( stderr, " attributes=%08x,", req->attributes );
1304     fprintf( stderr, " rootdir=%04x,", req->rootdir );
1305     fprintf( stderr, " name=" );
1306     dump_varargs_unicode_str( cur_size );
1307 }
1308
1309 static void dump_open_mutex_reply( const struct open_mutex_reply *req )
1310 {
1311     fprintf( stderr, " handle=%04x", req->handle );
1312 }
1313
1314 static void dump_create_semaphore_request( const struct create_semaphore_request *req )
1315 {
1316     fprintf( stderr, " access=%08x,", req->access );
1317     fprintf( stderr, " attributes=%08x,", req->attributes );
1318     fprintf( stderr, " initial=%08x,", req->initial );
1319     fprintf( stderr, " max=%08x,", req->max );
1320     fprintf( stderr, " objattr=" );
1321     dump_varargs_object_attributes( cur_size );
1322 }
1323
1324 static void dump_create_semaphore_reply( const struct create_semaphore_reply *req )
1325 {
1326     fprintf( stderr, " handle=%04x", req->handle );
1327 }
1328
1329 static void dump_release_semaphore_request( const struct release_semaphore_request *req )
1330 {
1331     fprintf( stderr, " handle=%04x,", req->handle );
1332     fprintf( stderr, " count=%08x", req->count );
1333 }
1334
1335 static void dump_release_semaphore_reply( const struct release_semaphore_reply *req )
1336 {
1337     fprintf( stderr, " prev_count=%08x", req->prev_count );
1338 }
1339
1340 static void dump_open_semaphore_request( const struct open_semaphore_request *req )
1341 {
1342     fprintf( stderr, " access=%08x,", req->access );
1343     fprintf( stderr, " attributes=%08x,", req->attributes );
1344     fprintf( stderr, " rootdir=%04x,", req->rootdir );
1345     fprintf( stderr, " name=" );
1346     dump_varargs_unicode_str( cur_size );
1347 }
1348
1349 static void dump_open_semaphore_reply( const struct open_semaphore_reply *req )
1350 {
1351     fprintf( stderr, " handle=%04x", req->handle );
1352 }
1353
1354 static void dump_create_file_request( const struct create_file_request *req )
1355 {
1356     fprintf( stderr, " access=%08x,", req->access );
1357     fprintf( stderr, " attributes=%08x,", req->attributes );
1358     fprintf( stderr, " sharing=%08x,", req->sharing );
1359     fprintf( stderr, " create=%d,", req->create );
1360     fprintf( stderr, " options=%08x,", req->options );
1361     fprintf( stderr, " attrs=%08x,", req->attrs );
1362     fprintf( stderr, " objattr=" );
1363     dump_varargs_object_attributes( cur_size );
1364     fputc( ',', stderr );
1365     fprintf( stderr, " filename=" );
1366     dump_varargs_string( cur_size );
1367 }
1368
1369 static void dump_create_file_reply( const struct create_file_reply *req )
1370 {
1371     fprintf( stderr, " handle=%04x", req->handle );
1372 }
1373
1374 static void dump_open_file_object_request( const struct open_file_object_request *req )
1375 {
1376     fprintf( stderr, " access=%08x,", req->access );
1377     fprintf( stderr, " attributes=%08x,", req->attributes );
1378     fprintf( stderr, " rootdir=%04x,", req->rootdir );
1379     fprintf( stderr, " sharing=%08x,", req->sharing );
1380     fprintf( stderr, " options=%08x,", req->options );
1381     fprintf( stderr, " filename=" );
1382     dump_varargs_unicode_str( cur_size );
1383 }
1384
1385 static void dump_open_file_object_reply( const struct open_file_object_reply *req )
1386 {
1387     fprintf( stderr, " handle=%04x", req->handle );
1388 }
1389
1390 static void dump_alloc_file_handle_request( const struct alloc_file_handle_request *req )
1391 {
1392     fprintf( stderr, " access=%08x,", req->access );
1393     fprintf( stderr, " attributes=%08x,", req->attributes );
1394     fprintf( stderr, " fd=%d", req->fd );
1395 }
1396
1397 static void dump_alloc_file_handle_reply( const struct alloc_file_handle_reply *req )
1398 {
1399     fprintf( stderr, " handle=%04x", req->handle );
1400 }
1401
1402 static void dump_get_handle_fd_request( const struct get_handle_fd_request *req )
1403 {
1404     fprintf( stderr, " handle=%04x", req->handle );
1405 }
1406
1407 static void dump_get_handle_fd_reply( const struct get_handle_fd_reply *req )
1408 {
1409     fprintf( stderr, " type=%d,", req->type );
1410     fprintf( stderr, " removable=%d,", req->removable );
1411     fprintf( stderr, " access=%08x,", req->access );
1412     fprintf( stderr, " options=%08x", req->options );
1413 }
1414
1415 static void dump_flush_file_request( const struct flush_file_request *req )
1416 {
1417     fprintf( stderr, " handle=%04x", req->handle );
1418 }
1419
1420 static void dump_flush_file_reply( const struct flush_file_reply *req )
1421 {
1422     fprintf( stderr, " event=%04x", req->event );
1423 }
1424
1425 static void dump_lock_file_request( const struct lock_file_request *req )
1426 {
1427     fprintf( stderr, " handle=%04x,", req->handle );
1428     fprintf( stderr, " offset=" );
1429     dump_uint64( &req->offset );
1430     fprintf( stderr, "," );
1431     fprintf( stderr, " count=" );
1432     dump_uint64( &req->count );
1433     fprintf( stderr, "," );
1434     fprintf( stderr, " shared=%d,", req->shared );
1435     fprintf( stderr, " wait=%d", req->wait );
1436 }
1437
1438 static void dump_lock_file_reply( const struct lock_file_reply *req )
1439 {
1440     fprintf( stderr, " handle=%04x,", req->handle );
1441     fprintf( stderr, " overlapped=%d", req->overlapped );
1442 }
1443
1444 static void dump_unlock_file_request( const struct unlock_file_request *req )
1445 {
1446     fprintf( stderr, " handle=%04x,", req->handle );
1447     fprintf( stderr, " offset=" );
1448     dump_uint64( &req->offset );
1449     fprintf( stderr, "," );
1450     fprintf( stderr, " count=" );
1451     dump_uint64( &req->count );
1452 }
1453
1454 static void dump_create_socket_request( const struct create_socket_request *req )
1455 {
1456     fprintf( stderr, " access=%08x,", req->access );
1457     fprintf( stderr, " attributes=%08x,", req->attributes );
1458     fprintf( stderr, " family=%d,", req->family );
1459     fprintf( stderr, " type=%d,", req->type );
1460     fprintf( stderr, " protocol=%d,", req->protocol );
1461     fprintf( stderr, " flags=%08x", req->flags );
1462 }
1463
1464 static void dump_create_socket_reply( const struct create_socket_reply *req )
1465 {
1466     fprintf( stderr, " handle=%04x", req->handle );
1467 }
1468
1469 static void dump_accept_socket_request( const struct accept_socket_request *req )
1470 {
1471     fprintf( stderr, " lhandle=%04x,", req->lhandle );
1472     fprintf( stderr, " access=%08x,", req->access );
1473     fprintf( stderr, " attributes=%08x", req->attributes );
1474 }
1475
1476 static void dump_accept_socket_reply( const struct accept_socket_reply *req )
1477 {
1478     fprintf( stderr, " handle=%04x", req->handle );
1479 }
1480
1481 static void dump_set_socket_event_request( const struct set_socket_event_request *req )
1482 {
1483     fprintf( stderr, " handle=%04x,", req->handle );
1484     fprintf( stderr, " mask=%08x,", req->mask );
1485     fprintf( stderr, " event=%04x,", req->event );
1486     fprintf( stderr, " window=%08x,", req->window );
1487     fprintf( stderr, " msg=%08x", req->msg );
1488 }
1489
1490 static void dump_get_socket_event_request( const struct get_socket_event_request *req )
1491 {
1492     fprintf( stderr, " handle=%04x,", req->handle );
1493     fprintf( stderr, " service=%d,", req->service );
1494     fprintf( stderr, " c_event=%04x", req->c_event );
1495 }
1496
1497 static void dump_get_socket_event_reply( const struct get_socket_event_reply *req )
1498 {
1499     fprintf( stderr, " mask=%08x,", req->mask );
1500     fprintf( stderr, " pmask=%08x,", req->pmask );
1501     fprintf( stderr, " state=%08x,", req->state );
1502     fprintf( stderr, " errors=" );
1503     dump_varargs_ints( cur_size );
1504 }
1505
1506 static void dump_enable_socket_event_request( const struct enable_socket_event_request *req )
1507 {
1508     fprintf( stderr, " handle=%04x,", req->handle );
1509     fprintf( stderr, " mask=%08x,", req->mask );
1510     fprintf( stderr, " sstate=%08x,", req->sstate );
1511     fprintf( stderr, " cstate=%08x", req->cstate );
1512 }
1513
1514 static void dump_set_socket_deferred_request( const struct set_socket_deferred_request *req )
1515 {
1516     fprintf( stderr, " handle=%04x,", req->handle );
1517     fprintf( stderr, " deferred=%04x", req->deferred );
1518 }
1519
1520 static void dump_alloc_console_request( const struct alloc_console_request *req )
1521 {
1522     fprintf( stderr, " access=%08x,", req->access );
1523     fprintf( stderr, " attributes=%08x,", req->attributes );
1524     fprintf( stderr, " pid=%04x", req->pid );
1525 }
1526
1527 static void dump_alloc_console_reply( const struct alloc_console_reply *req )
1528 {
1529     fprintf( stderr, " handle_in=%04x,", req->handle_in );
1530     fprintf( stderr, " event=%04x", req->event );
1531 }
1532
1533 static void dump_free_console_request( const struct free_console_request *req )
1534 {
1535 }
1536
1537 static void dump_get_console_renderer_events_request( const struct get_console_renderer_events_request *req )
1538 {
1539     fprintf( stderr, " handle=%04x", req->handle );
1540 }
1541
1542 static void dump_get_console_renderer_events_reply( const struct get_console_renderer_events_reply *req )
1543 {
1544     fprintf( stderr, " data=" );
1545     dump_varargs_bytes( cur_size );
1546 }
1547
1548 static void dump_open_console_request( const struct open_console_request *req )
1549 {
1550     fprintf( stderr, " from=%04x,", req->from );
1551     fprintf( stderr, " access=%08x,", req->access );
1552     fprintf( stderr, " attributes=%08x,", req->attributes );
1553     fprintf( stderr, " share=%d", req->share );
1554 }
1555
1556 static void dump_open_console_reply( const struct open_console_reply *req )
1557 {
1558     fprintf( stderr, " handle=%04x", req->handle );
1559 }
1560
1561 static void dump_get_console_wait_event_request( const struct get_console_wait_event_request *req )
1562 {
1563 }
1564
1565 static void dump_get_console_wait_event_reply( const struct get_console_wait_event_reply *req )
1566 {
1567     fprintf( stderr, " handle=%04x", req->handle );
1568 }
1569
1570 static void dump_get_console_mode_request( const struct get_console_mode_request *req )
1571 {
1572     fprintf( stderr, " handle=%04x", req->handle );
1573 }
1574
1575 static void dump_get_console_mode_reply( const struct get_console_mode_reply *req )
1576 {
1577     fprintf( stderr, " mode=%d", req->mode );
1578 }
1579
1580 static void dump_set_console_mode_request( const struct set_console_mode_request *req )
1581 {
1582     fprintf( stderr, " handle=%04x,", req->handle );
1583     fprintf( stderr, " mode=%d", req->mode );
1584 }
1585
1586 static void dump_set_console_input_info_request( const struct set_console_input_info_request *req )
1587 {
1588     fprintf( stderr, " handle=%04x,", req->handle );
1589     fprintf( stderr, " mask=%d,", req->mask );
1590     fprintf( stderr, " active_sb=%04x,", req->active_sb );
1591     fprintf( stderr, " history_mode=%d,", req->history_mode );
1592     fprintf( stderr, " history_size=%d,", req->history_size );
1593     fprintf( stderr, " edition_mode=%d,", req->edition_mode );
1594     fprintf( stderr, " input_cp=%d,", req->input_cp );
1595     fprintf( stderr, " output_cp=%d,", req->output_cp );
1596     fprintf( stderr, " win=%08x,", req->win );
1597     fprintf( stderr, " title=" );
1598     dump_varargs_unicode_str( cur_size );
1599 }
1600
1601 static void dump_get_console_input_info_request( const struct get_console_input_info_request *req )
1602 {
1603     fprintf( stderr, " handle=%04x", req->handle );
1604 }
1605
1606 static void dump_get_console_input_info_reply( const struct get_console_input_info_reply *req )
1607 {
1608     fprintf( stderr, " history_mode=%d,", req->history_mode );
1609     fprintf( stderr, " history_size=%d,", req->history_size );
1610     fprintf( stderr, " history_index=%d,", req->history_index );
1611     fprintf( stderr, " edition_mode=%d,", req->edition_mode );
1612     fprintf( stderr, " input_cp=%d,", req->input_cp );
1613     fprintf( stderr, " output_cp=%d,", req->output_cp );
1614     fprintf( stderr, " win=%08x,", req->win );
1615     fprintf( stderr, " title=" );
1616     dump_varargs_unicode_str( cur_size );
1617 }
1618
1619 static void dump_append_console_input_history_request( const struct append_console_input_history_request *req )
1620 {
1621     fprintf( stderr, " handle=%04x,", req->handle );
1622     fprintf( stderr, " line=" );
1623     dump_varargs_unicode_str( cur_size );
1624 }
1625
1626 static void dump_get_console_input_history_request( const struct get_console_input_history_request *req )
1627 {
1628     fprintf( stderr, " handle=%04x,", req->handle );
1629     fprintf( stderr, " index=%d", req->index );
1630 }
1631
1632 static void dump_get_console_input_history_reply( const struct get_console_input_history_reply *req )
1633 {
1634     fprintf( stderr, " total=%d,", req->total );
1635     fprintf( stderr, " line=" );
1636     dump_varargs_unicode_str( cur_size );
1637 }
1638
1639 static void dump_create_console_output_request( const struct create_console_output_request *req )
1640 {
1641     fprintf( stderr, " handle_in=%04x,", req->handle_in );
1642     fprintf( stderr, " access=%08x,", req->access );
1643     fprintf( stderr, " attributes=%08x,", req->attributes );
1644     fprintf( stderr, " share=%08x", req->share );
1645 }
1646
1647 static void dump_create_console_output_reply( const struct create_console_output_reply *req )
1648 {
1649     fprintf( stderr, " handle_out=%04x", req->handle_out );
1650 }
1651
1652 static void dump_set_console_output_info_request( const struct set_console_output_info_request *req )
1653 {
1654     fprintf( stderr, " handle=%04x,", req->handle );
1655     fprintf( stderr, " mask=%d,", req->mask );
1656     fprintf( stderr, " cursor_size=%d,", req->cursor_size );
1657     fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
1658     fprintf( stderr, " cursor_x=%d,", req->cursor_x );
1659     fprintf( stderr, " cursor_y=%d,", req->cursor_y );
1660     fprintf( stderr, " width=%d,", req->width );
1661     fprintf( stderr, " height=%d,", req->height );
1662     fprintf( stderr, " attr=%d,", req->attr );
1663     fprintf( stderr, " win_left=%d,", req->win_left );
1664     fprintf( stderr, " win_top=%d,", req->win_top );
1665     fprintf( stderr, " win_right=%d,", req->win_right );
1666     fprintf( stderr, " win_bottom=%d,", req->win_bottom );
1667     fprintf( stderr, " max_width=%d,", req->max_width );
1668     fprintf( stderr, " max_height=%d", req->max_height );
1669 }
1670
1671 static void dump_get_console_output_info_request( const struct get_console_output_info_request *req )
1672 {
1673     fprintf( stderr, " handle=%04x", req->handle );
1674 }
1675
1676 static void dump_get_console_output_info_reply( const struct get_console_output_info_reply *req )
1677 {
1678     fprintf( stderr, " cursor_size=%d,", req->cursor_size );
1679     fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
1680     fprintf( stderr, " cursor_x=%d,", req->cursor_x );
1681     fprintf( stderr, " cursor_y=%d,", req->cursor_y );
1682     fprintf( stderr, " width=%d,", req->width );
1683     fprintf( stderr, " height=%d,", req->height );
1684     fprintf( stderr, " attr=%d,", req->attr );
1685     fprintf( stderr, " win_left=%d,", req->win_left );
1686     fprintf( stderr, " win_top=%d,", req->win_top );
1687     fprintf( stderr, " win_right=%d,", req->win_right );
1688     fprintf( stderr, " win_bottom=%d,", req->win_bottom );
1689     fprintf( stderr, " max_width=%d,", req->max_width );
1690     fprintf( stderr, " max_height=%d", req->max_height );
1691 }
1692
1693 static void dump_write_console_input_request( const struct write_console_input_request *req )
1694 {
1695     fprintf( stderr, " handle=%04x,", req->handle );
1696     fprintf( stderr, " rec=" );
1697     dump_varargs_input_records( cur_size );
1698 }
1699
1700 static void dump_write_console_input_reply( const struct write_console_input_reply *req )
1701 {
1702     fprintf( stderr, " written=%d", req->written );
1703 }
1704
1705 static void dump_read_console_input_request( const struct read_console_input_request *req )
1706 {
1707     fprintf( stderr, " handle=%04x,", req->handle );
1708     fprintf( stderr, " flush=%d", req->flush );
1709 }
1710
1711 static void dump_read_console_input_reply( const struct read_console_input_reply *req )
1712 {
1713     fprintf( stderr, " read=%d,", req->read );
1714     fprintf( stderr, " rec=" );
1715     dump_varargs_input_records( cur_size );
1716 }
1717
1718 static void dump_write_console_output_request( const struct write_console_output_request *req )
1719 {
1720     fprintf( stderr, " handle=%04x,", req->handle );
1721     fprintf( stderr, " x=%d,", req->x );
1722     fprintf( stderr, " y=%d,", req->y );
1723     fprintf( stderr, " mode=%d,", req->mode );
1724     fprintf( stderr, " wrap=%d,", req->wrap );
1725     fprintf( stderr, " data=" );
1726     dump_varargs_bytes( cur_size );
1727 }
1728
1729 static void dump_write_console_output_reply( const struct write_console_output_reply *req )
1730 {
1731     fprintf( stderr, " written=%d,", req->written );
1732     fprintf( stderr, " width=%d,", req->width );
1733     fprintf( stderr, " height=%d", req->height );
1734 }
1735
1736 static void dump_fill_console_output_request( const struct fill_console_output_request *req )
1737 {
1738     fprintf( stderr, " handle=%04x,", req->handle );
1739     fprintf( stderr, " x=%d,", req->x );
1740     fprintf( stderr, " y=%d,", req->y );
1741     fprintf( stderr, " mode=%d,", req->mode );
1742     fprintf( stderr, " count=%d,", req->count );
1743     fprintf( stderr, " wrap=%d,", req->wrap );
1744     fprintf( stderr, " data=" );
1745     dump_char_info( &req->data );
1746 }
1747
1748 static void dump_fill_console_output_reply( const struct fill_console_output_reply *req )
1749 {
1750     fprintf( stderr, " written=%d", req->written );
1751 }
1752
1753 static void dump_read_console_output_request( const struct read_console_output_request *req )
1754 {
1755     fprintf( stderr, " handle=%04x,", req->handle );
1756     fprintf( stderr, " x=%d,", req->x );
1757     fprintf( stderr, " y=%d,", req->y );
1758     fprintf( stderr, " mode=%d,", req->mode );
1759     fprintf( stderr, " wrap=%d", req->wrap );
1760 }
1761
1762 static void dump_read_console_output_reply( const struct read_console_output_reply *req )
1763 {
1764     fprintf( stderr, " width=%d,", req->width );
1765     fprintf( stderr, " height=%d,", req->height );
1766     fprintf( stderr, " data=" );
1767     dump_varargs_bytes( cur_size );
1768 }
1769
1770 static void dump_move_console_output_request( const struct move_console_output_request *req )
1771 {
1772     fprintf( stderr, " handle=%04x,", req->handle );
1773     fprintf( stderr, " x_src=%d,", req->x_src );
1774     fprintf( stderr, " y_src=%d,", req->y_src );
1775     fprintf( stderr, " x_dst=%d,", req->x_dst );
1776     fprintf( stderr, " y_dst=%d,", req->y_dst );
1777     fprintf( stderr, " w=%d,", req->w );
1778     fprintf( stderr, " h=%d", req->h );
1779 }
1780
1781 static void dump_send_console_signal_request( const struct send_console_signal_request *req )
1782 {
1783     fprintf( stderr, " signal=%d,", req->signal );
1784     fprintf( stderr, " group_id=%04x", req->group_id );
1785 }
1786
1787 static void dump_read_directory_changes_request( const struct read_directory_changes_request *req )
1788 {
1789     fprintf( stderr, " filter=%08x,", req->filter );
1790     fprintf( stderr, " subtree=%d,", req->subtree );
1791     fprintf( stderr, " want_data=%d,", req->want_data );
1792     fprintf( stderr, " async=" );
1793     dump_async_data( &req->async );
1794 }
1795
1796 static void dump_read_change_request( const struct read_change_request *req )
1797 {
1798     fprintf( stderr, " handle=%04x", req->handle );
1799 }
1800
1801 static void dump_read_change_reply( const struct read_change_reply *req )
1802 {
1803     fprintf( stderr, " action=%d,", req->action );
1804     fprintf( stderr, " name=" );
1805     dump_varargs_string( cur_size );
1806 }
1807
1808 static void dump_create_mapping_request( const struct create_mapping_request *req )
1809 {
1810     fprintf( stderr, " access=%08x,", req->access );
1811     fprintf( stderr, " attributes=%08x,", req->attributes );
1812     fprintf( stderr, " size=" );
1813     dump_uint64( &req->size );
1814     fprintf( stderr, "," );
1815     fprintf( stderr, " protect=%08x,", req->protect );
1816     fprintf( stderr, " file_handle=%04x,", req->file_handle );
1817     fprintf( stderr, " objattr=" );
1818     dump_varargs_object_attributes( cur_size );
1819 }
1820
1821 static void dump_create_mapping_reply( const struct create_mapping_reply *req )
1822 {
1823     fprintf( stderr, " handle=%04x", req->handle );
1824 }
1825
1826 static void dump_open_mapping_request( const struct open_mapping_request *req )
1827 {
1828     fprintf( stderr, " access=%08x,", req->access );
1829     fprintf( stderr, " attributes=%08x,", req->attributes );
1830     fprintf( stderr, " rootdir=%04x,", req->rootdir );
1831     fprintf( stderr, " name=" );
1832     dump_varargs_unicode_str( cur_size );
1833 }
1834
1835 static void dump_open_mapping_reply( const struct open_mapping_reply *req )
1836 {
1837     fprintf( stderr, " handle=%04x", req->handle );
1838 }
1839
1840 static void dump_get_mapping_info_request( const struct get_mapping_info_request *req )
1841 {
1842     fprintf( stderr, " handle=%04x,", req->handle );
1843     fprintf( stderr, " access=%08x", req->access );
1844 }
1845
1846 static void dump_get_mapping_info_reply( const struct get_mapping_info_reply *req )
1847 {
1848     fprintf( stderr, " size=" );
1849     dump_uint64( &req->size );
1850     fprintf( stderr, "," );
1851     fprintf( stderr, " protect=%d,", req->protect );
1852     fprintf( stderr, " header_size=%d,", req->header_size );
1853     fprintf( stderr, " base=" );
1854     dump_uint64( &req->base );
1855     fprintf( stderr, "," );
1856     fprintf( stderr, " mapping=%04x,", req->mapping );
1857     fprintf( stderr, " shared_file=%04x", req->shared_file );
1858 }
1859
1860 static void dump_get_mapping_committed_range_request( const struct get_mapping_committed_range_request *req )
1861 {
1862     fprintf( stderr, " handle=%04x,", req->handle );
1863     fprintf( stderr, " offset=" );
1864     dump_uint64( &req->offset );
1865 }
1866
1867 static void dump_get_mapping_committed_range_reply( const struct get_mapping_committed_range_reply *req )
1868 {
1869     fprintf( stderr, " size=" );
1870     dump_uint64( &req->size );
1871     fprintf( stderr, "," );
1872     fprintf( stderr, " committed=%d", req->committed );
1873 }
1874
1875 static void dump_add_mapping_committed_range_request( const struct add_mapping_committed_range_request *req )
1876 {
1877     fprintf( stderr, " handle=%04x,", req->handle );
1878     fprintf( stderr, " offset=" );
1879     dump_uint64( &req->offset );
1880     fprintf( stderr, "," );
1881     fprintf( stderr, " size=" );
1882     dump_uint64( &req->size );
1883 }
1884
1885 static void dump_create_snapshot_request( const struct create_snapshot_request *req )
1886 {
1887     fprintf( stderr, " attributes=%08x,", req->attributes );
1888     fprintf( stderr, " flags=%08x", req->flags );
1889 }
1890
1891 static void dump_create_snapshot_reply( const struct create_snapshot_reply *req )
1892 {
1893     fprintf( stderr, " handle=%04x", req->handle );
1894 }
1895
1896 static void dump_next_process_request( const struct next_process_request *req )
1897 {
1898     fprintf( stderr, " handle=%04x,", req->handle );
1899     fprintf( stderr, " reset=%d", req->reset );
1900 }
1901
1902 static void dump_next_process_reply( const struct next_process_reply *req )
1903 {
1904     fprintf( stderr, " count=%d,", req->count );
1905     fprintf( stderr, " pid=%04x,", req->pid );
1906     fprintf( stderr, " ppid=%04x,", req->ppid );
1907     fprintf( stderr, " threads=%d,", req->threads );
1908     fprintf( stderr, " priority=%d,", req->priority );
1909     fprintf( stderr, " handles=%d,", req->handles );
1910     fprintf( stderr, " filename=" );
1911     dump_varargs_unicode_str( cur_size );
1912 }
1913
1914 static void dump_next_thread_request( const struct next_thread_request *req )
1915 {
1916     fprintf( stderr, " handle=%04x,", req->handle );
1917     fprintf( stderr, " reset=%d", req->reset );
1918 }
1919
1920 static void dump_next_thread_reply( const struct next_thread_reply *req )
1921 {
1922     fprintf( stderr, " count=%d,", req->count );
1923     fprintf( stderr, " pid=%04x,", req->pid );
1924     fprintf( stderr, " tid=%04x,", req->tid );
1925     fprintf( stderr, " base_pri=%d,", req->base_pri );
1926     fprintf( stderr, " delta_pri=%d", req->delta_pri );
1927 }
1928
1929 static void dump_wait_debug_event_request( const struct wait_debug_event_request *req )
1930 {
1931     fprintf( stderr, " get_handle=%d", req->get_handle );
1932 }
1933
1934 static void dump_wait_debug_event_reply( const struct wait_debug_event_reply *req )
1935 {
1936     fprintf( stderr, " pid=%04x,", req->pid );
1937     fprintf( stderr, " tid=%04x,", req->tid );
1938     fprintf( stderr, " wait=%04x,", req->wait );
1939     fprintf( stderr, " event=" );
1940     dump_varargs_debug_event( cur_size );
1941 }
1942
1943 static void dump_queue_exception_event_request( const struct queue_exception_event_request *req )
1944 {
1945     fprintf( stderr, " first=%d,", req->first );
1946     fprintf( stderr, " record=" );
1947     dump_varargs_exc_event( cur_size );
1948 }
1949
1950 static void dump_queue_exception_event_reply( const struct queue_exception_event_reply *req )
1951 {
1952     fprintf( stderr, " handle=%04x", req->handle );
1953 }
1954
1955 static void dump_get_exception_status_request( const struct get_exception_status_request *req )
1956 {
1957     fprintf( stderr, " handle=%04x", req->handle );
1958 }
1959
1960 static void dump_get_exception_status_reply( const struct get_exception_status_reply *req )
1961 {
1962     fprintf( stderr, " context=" );
1963     dump_varargs_context( cur_size );
1964 }
1965
1966 static void dump_output_debug_string_request( const struct output_debug_string_request *req )
1967 {
1968     fprintf( stderr, " length=%u,", req->length );
1969     fprintf( stderr, " string=" );
1970     dump_uint64( &req->string );
1971     fprintf( stderr, "," );
1972     fprintf( stderr, " unicode=%d", req->unicode );
1973 }
1974
1975 static void dump_continue_debug_event_request( const struct continue_debug_event_request *req )
1976 {
1977     fprintf( stderr, " pid=%04x,", req->pid );
1978     fprintf( stderr, " tid=%04x,", req->tid );
1979     fprintf( stderr, " status=%d", req->status );
1980 }
1981
1982 static void dump_debug_process_request( const struct debug_process_request *req )
1983 {
1984     fprintf( stderr, " pid=%04x,", req->pid );
1985     fprintf( stderr, " attach=%d", req->attach );
1986 }
1987
1988 static void dump_debug_break_request( const struct debug_break_request *req )
1989 {
1990     fprintf( stderr, " handle=%04x", req->handle );
1991 }
1992
1993 static void dump_debug_break_reply( const struct debug_break_reply *req )
1994 {
1995     fprintf( stderr, " self=%d", req->self );
1996 }
1997
1998 static void dump_set_debugger_kill_on_exit_request( const struct set_debugger_kill_on_exit_request *req )
1999 {
2000     fprintf( stderr, " kill_on_exit=%d", req->kill_on_exit );
2001 }
2002
2003 static void dump_read_process_memory_request( const struct read_process_memory_request *req )
2004 {
2005     fprintf( stderr, " handle=%04x,", req->handle );
2006     fprintf( stderr, " addr=" );
2007     dump_uint64( &req->addr );
2008 }
2009
2010 static void dump_read_process_memory_reply( const struct read_process_memory_reply *req )
2011 {
2012     fprintf( stderr, " data=" );
2013     dump_varargs_bytes( cur_size );
2014 }
2015
2016 static void dump_write_process_memory_request( const struct write_process_memory_request *req )
2017 {
2018     fprintf( stderr, " handle=%04x,", req->handle );
2019     fprintf( stderr, " addr=" );
2020     dump_uint64( &req->addr );
2021     fprintf( stderr, "," );
2022     fprintf( stderr, " data=" );
2023     dump_varargs_bytes( cur_size );
2024 }
2025
2026 static void dump_create_key_request( const struct create_key_request *req )
2027 {
2028     fprintf( stderr, " parent=%04x,", req->parent );
2029     fprintf( stderr, " access=%08x,", req->access );
2030     fprintf( stderr, " attributes=%08x,", req->attributes );
2031     fprintf( stderr, " options=%08x,", req->options );
2032     fprintf( stderr, " namelen=%u,", req->namelen );
2033     fprintf( stderr, " name=" );
2034     dump_varargs_unicode_str( min(cur_size,req->namelen) );
2035     fputc( ',', stderr );
2036     fprintf( stderr, " class=" );
2037     dump_varargs_unicode_str( cur_size );
2038 }
2039
2040 static void dump_create_key_reply( const struct create_key_reply *req )
2041 {
2042     fprintf( stderr, " hkey=%04x,", req->hkey );
2043     fprintf( stderr, " created=%d", req->created );
2044 }
2045
2046 static void dump_open_key_request( const struct open_key_request *req )
2047 {
2048     fprintf( stderr, " parent=%04x,", req->parent );
2049     fprintf( stderr, " access=%08x,", req->access );
2050     fprintf( stderr, " attributes=%08x,", req->attributes );
2051     fprintf( stderr, " name=" );
2052     dump_varargs_unicode_str( cur_size );
2053 }
2054
2055 static void dump_open_key_reply( const struct open_key_reply *req )
2056 {
2057     fprintf( stderr, " hkey=%04x", req->hkey );
2058 }
2059
2060 static void dump_delete_key_request( const struct delete_key_request *req )
2061 {
2062     fprintf( stderr, " hkey=%04x", req->hkey );
2063 }
2064
2065 static void dump_flush_key_request( const struct flush_key_request *req )
2066 {
2067     fprintf( stderr, " hkey=%04x", req->hkey );
2068 }
2069
2070 static void dump_enum_key_request( const struct enum_key_request *req )
2071 {
2072     fprintf( stderr, " hkey=%04x,", req->hkey );
2073     fprintf( stderr, " index=%d,", req->index );
2074     fprintf( stderr, " info_class=%d", req->info_class );
2075 }
2076
2077 static void dump_enum_key_reply( const struct enum_key_reply *req )
2078 {
2079     fprintf( stderr, " subkeys=%d,", req->subkeys );
2080     fprintf( stderr, " max_subkey=%d,", req->max_subkey );
2081     fprintf( stderr, " max_class=%d,", req->max_class );
2082     fprintf( stderr, " values=%d,", req->values );
2083     fprintf( stderr, " max_value=%d,", req->max_value );
2084     fprintf( stderr, " max_data=%d,", req->max_data );
2085     fprintf( stderr, " modif=" );
2086     dump_timeout( &req->modif );
2087     fprintf( stderr, "," );
2088     fprintf( stderr, " total=%u,", req->total );
2089     fprintf( stderr, " namelen=%u,", req->namelen );
2090     fprintf( stderr, " name=" );
2091     dump_varargs_unicode_str( min(cur_size,req->namelen) );
2092     fputc( ',', stderr );
2093     fprintf( stderr, " class=" );
2094     dump_varargs_unicode_str( cur_size );
2095 }
2096
2097 static void dump_set_key_value_request( const struct set_key_value_request *req )
2098 {
2099     fprintf( stderr, " hkey=%04x,", req->hkey );
2100     fprintf( stderr, " type=%d,", req->type );
2101     fprintf( stderr, " namelen=%u,", req->namelen );
2102     fprintf( stderr, " name=" );
2103     dump_varargs_unicode_str( min(cur_size,req->namelen) );
2104     fputc( ',', stderr );
2105     fprintf( stderr, " data=" );
2106     dump_varargs_bytes( cur_size );
2107 }
2108
2109 static void dump_get_key_value_request( const struct get_key_value_request *req )
2110 {
2111     fprintf( stderr, " hkey=%04x,", req->hkey );
2112     fprintf( stderr, " name=" );
2113     dump_varargs_unicode_str( cur_size );
2114 }
2115
2116 static void dump_get_key_value_reply( const struct get_key_value_reply *req )
2117 {
2118     fprintf( stderr, " type=%d,", req->type );
2119     fprintf( stderr, " total=%u,", req->total );
2120     fprintf( stderr, " data=" );
2121     dump_varargs_bytes( cur_size );
2122 }
2123
2124 static void dump_enum_key_value_request( const struct enum_key_value_request *req )
2125 {
2126     fprintf( stderr, " hkey=%04x,", req->hkey );
2127     fprintf( stderr, " index=%d,", req->index );
2128     fprintf( stderr, " info_class=%d", req->info_class );
2129 }
2130
2131 static void dump_enum_key_value_reply( const struct enum_key_value_reply *req )
2132 {
2133     fprintf( stderr, " type=%d,", req->type );
2134     fprintf( stderr, " total=%u,", req->total );
2135     fprintf( stderr, " namelen=%u,", req->namelen );
2136     fprintf( stderr, " name=" );
2137     dump_varargs_unicode_str( min(cur_size,req->namelen) );
2138     fputc( ',', stderr );
2139     fprintf( stderr, " data=" );
2140     dump_varargs_bytes( cur_size );
2141 }
2142
2143 static void dump_delete_key_value_request( const struct delete_key_value_request *req )
2144 {
2145     fprintf( stderr, " hkey=%04x,", req->hkey );
2146     fprintf( stderr, " name=" );
2147     dump_varargs_unicode_str( cur_size );
2148 }
2149
2150 static void dump_load_registry_request( const struct load_registry_request *req )
2151 {
2152     fprintf( stderr, " hkey=%04x,", req->hkey );
2153     fprintf( stderr, " file=%04x,", req->file );
2154     fprintf( stderr, " name=" );
2155     dump_varargs_unicode_str( cur_size );
2156 }
2157
2158 static void dump_unload_registry_request( const struct unload_registry_request *req )
2159 {
2160     fprintf( stderr, " hkey=%04x", req->hkey );
2161 }
2162
2163 static void dump_save_registry_request( const struct save_registry_request *req )
2164 {
2165     fprintf( stderr, " hkey=%04x,", req->hkey );
2166     fprintf( stderr, " file=%04x", req->file );
2167 }
2168
2169 static void dump_set_registry_notification_request( const struct set_registry_notification_request *req )
2170 {
2171     fprintf( stderr, " hkey=%04x,", req->hkey );
2172     fprintf( stderr, " event=%04x,", req->event );
2173     fprintf( stderr, " subtree=%d,", req->subtree );
2174     fprintf( stderr, " filter=%08x", req->filter );
2175 }
2176
2177 static void dump_create_timer_request( const struct create_timer_request *req )
2178 {
2179     fprintf( stderr, " access=%08x,", req->access );
2180     fprintf( stderr, " attributes=%08x,", req->attributes );
2181     fprintf( stderr, " rootdir=%04x,", req->rootdir );
2182     fprintf( stderr, " manual=%d,", req->manual );
2183     fprintf( stderr, " name=" );
2184     dump_varargs_unicode_str( cur_size );
2185 }
2186
2187 static void dump_create_timer_reply( const struct create_timer_reply *req )
2188 {
2189     fprintf( stderr, " handle=%04x", req->handle );
2190 }
2191
2192 static void dump_open_timer_request( const struct open_timer_request *req )
2193 {
2194     fprintf( stderr, " access=%08x,", req->access );
2195     fprintf( stderr, " attributes=%08x,", req->attributes );
2196     fprintf( stderr, " rootdir=%04x,", req->rootdir );
2197     fprintf( stderr, " name=" );
2198     dump_varargs_unicode_str( cur_size );
2199 }
2200
2201 static void dump_open_timer_reply( const struct open_timer_reply *req )
2202 {
2203     fprintf( stderr, " handle=%04x", req->handle );
2204 }
2205
2206 static void dump_set_timer_request( const struct set_timer_request *req )
2207 {
2208     fprintf( stderr, " handle=%04x,", req->handle );
2209     fprintf( stderr, " expire=" );
2210     dump_timeout( &req->expire );
2211     fprintf( stderr, "," );
2212     fprintf( stderr, " callback=" );
2213     dump_uint64( &req->callback );
2214     fprintf( stderr, "," );
2215     fprintf( stderr, " arg=" );
2216     dump_uint64( &req->arg );
2217     fprintf( stderr, "," );
2218     fprintf( stderr, " period=%d", req->period );
2219 }
2220
2221 static void dump_set_timer_reply( const struct set_timer_reply *req )
2222 {
2223     fprintf( stderr, " signaled=%d", req->signaled );
2224 }
2225
2226 static void dump_cancel_timer_request( const struct cancel_timer_request *req )
2227 {
2228     fprintf( stderr, " handle=%04x", req->handle );
2229 }
2230
2231 static void dump_cancel_timer_reply( const struct cancel_timer_reply *req )
2232 {
2233     fprintf( stderr, " signaled=%d", req->signaled );
2234 }
2235
2236 static void dump_get_timer_info_request( const struct get_timer_info_request *req )
2237 {
2238     fprintf( stderr, " handle=%04x", req->handle );
2239 }
2240
2241 static void dump_get_timer_info_reply( const struct get_timer_info_reply *req )
2242 {
2243     fprintf( stderr, " when=" );
2244     dump_timeout( &req->when );
2245     fprintf( stderr, "," );
2246     fprintf( stderr, " signaled=%d", req->signaled );
2247 }
2248
2249 static void dump_get_thread_context_request( const struct get_thread_context_request *req )
2250 {
2251     fprintf( stderr, " handle=%04x,", req->handle );
2252     fprintf( stderr, " flags=%08x,", req->flags );
2253     fprintf( stderr, " suspend=%d", req->suspend );
2254 }
2255
2256 static void dump_get_thread_context_reply( const struct get_thread_context_reply *req )
2257 {
2258     fprintf( stderr, " self=%d,", req->self );
2259     fprintf( stderr, " context=" );
2260     dump_varargs_context( cur_size );
2261 }
2262
2263 static void dump_set_thread_context_request( const struct set_thread_context_request *req )
2264 {
2265     fprintf( stderr, " handle=%04x,", req->handle );
2266     fprintf( stderr, " flags=%08x,", req->flags );
2267     fprintf( stderr, " suspend=%d,", req->suspend );
2268     fprintf( stderr, " context=" );
2269     dump_varargs_context( cur_size );
2270 }
2271
2272 static void dump_set_thread_context_reply( const struct set_thread_context_reply *req )
2273 {
2274     fprintf( stderr, " self=%d", req->self );
2275 }
2276
2277 static void dump_get_selector_entry_request( const struct get_selector_entry_request *req )
2278 {
2279     fprintf( stderr, " handle=%04x,", req->handle );
2280     fprintf( stderr, " entry=%d", req->entry );
2281 }
2282
2283 static void dump_get_selector_entry_reply( const struct get_selector_entry_reply *req )
2284 {
2285     fprintf( stderr, " base=%08x,", req->base );
2286     fprintf( stderr, " limit=%08x,", req->limit );
2287     fprintf( stderr, " flags=%02x", req->flags );
2288 }
2289
2290 static void dump_add_atom_request( const struct add_atom_request *req )
2291 {
2292     fprintf( stderr, " table=%04x,", req->table );
2293     fprintf( stderr, " name=" );
2294     dump_varargs_unicode_str( cur_size );
2295 }
2296
2297 static void dump_add_atom_reply( const struct add_atom_reply *req )
2298 {
2299     fprintf( stderr, " atom=%04x", req->atom );
2300 }
2301
2302 static void dump_delete_atom_request( const struct delete_atom_request *req )
2303 {
2304     fprintf( stderr, " table=%04x,", req->table );
2305     fprintf( stderr, " atom=%04x", req->atom );
2306 }
2307
2308 static void dump_find_atom_request( const struct find_atom_request *req )
2309 {
2310     fprintf( stderr, " table=%04x,", req->table );
2311     fprintf( stderr, " name=" );
2312     dump_varargs_unicode_str( cur_size );
2313 }
2314
2315 static void dump_find_atom_reply( const struct find_atom_reply *req )
2316 {
2317     fprintf( stderr, " atom=%04x", req->atom );
2318 }
2319
2320 static void dump_get_atom_information_request( const struct get_atom_information_request *req )
2321 {
2322     fprintf( stderr, " table=%04x,", req->table );
2323     fprintf( stderr, " atom=%04x", req->atom );
2324 }
2325
2326 static void dump_get_atom_information_reply( const struct get_atom_information_reply *req )
2327 {
2328     fprintf( stderr, " count=%d,", req->count );
2329     fprintf( stderr, " pinned=%d,", req->pinned );
2330     fprintf( stderr, " total=%u,", req->total );
2331     fprintf( stderr, " name=" );
2332     dump_varargs_unicode_str( cur_size );
2333 }
2334
2335 static void dump_set_atom_information_request( const struct set_atom_information_request *req )
2336 {
2337     fprintf( stderr, " table=%04x,", req->table );
2338     fprintf( stderr, " atom=%04x,", req->atom );
2339     fprintf( stderr, " pinned=%d", req->pinned );
2340 }
2341
2342 static void dump_empty_atom_table_request( const struct empty_atom_table_request *req )
2343 {
2344     fprintf( stderr, " table=%04x,", req->table );
2345     fprintf( stderr, " if_pinned=%d", req->if_pinned );
2346 }
2347
2348 static void dump_init_atom_table_request( const struct init_atom_table_request *req )
2349 {
2350     fprintf( stderr, " entries=%d", req->entries );
2351 }
2352
2353 static void dump_init_atom_table_reply( const struct init_atom_table_reply *req )
2354 {
2355     fprintf( stderr, " table=%04x", req->table );
2356 }
2357
2358 static void dump_get_msg_queue_request( const struct get_msg_queue_request *req )
2359 {
2360 }
2361
2362 static void dump_get_msg_queue_reply( const struct get_msg_queue_reply *req )
2363 {
2364     fprintf( stderr, " handle=%04x", req->handle );
2365 }
2366
2367 static void dump_set_queue_fd_request( const struct set_queue_fd_request *req )
2368 {
2369     fprintf( stderr, " handle=%04x", req->handle );
2370 }
2371
2372 static void dump_set_queue_mask_request( const struct set_queue_mask_request *req )
2373 {
2374     fprintf( stderr, " wake_mask=%08x,", req->wake_mask );
2375     fprintf( stderr, " changed_mask=%08x,", req->changed_mask );
2376     fprintf( stderr, " skip_wait=%d", req->skip_wait );
2377 }
2378
2379 static void dump_set_queue_mask_reply( const struct set_queue_mask_reply *req )
2380 {
2381     fprintf( stderr, " wake_bits=%08x,", req->wake_bits );
2382     fprintf( stderr, " changed_bits=%08x", req->changed_bits );
2383 }
2384
2385 static void dump_get_queue_status_request( const struct get_queue_status_request *req )
2386 {
2387     fprintf( stderr, " clear=%d", req->clear );
2388 }
2389
2390 static void dump_get_queue_status_reply( const struct get_queue_status_reply *req )
2391 {
2392     fprintf( stderr, " wake_bits=%08x,", req->wake_bits );
2393     fprintf( stderr, " changed_bits=%08x", req->changed_bits );
2394 }
2395
2396 static void dump_get_process_idle_event_request( const struct get_process_idle_event_request *req )
2397 {
2398     fprintf( stderr, " handle=%04x", req->handle );
2399 }
2400
2401 static void dump_get_process_idle_event_reply( const struct get_process_idle_event_reply *req )
2402 {
2403     fprintf( stderr, " event=%04x", req->event );
2404 }
2405
2406 static void dump_send_message_request( const struct send_message_request *req )
2407 {
2408     fprintf( stderr, " id=%04x,", req->id );
2409     fprintf( stderr, " type=%d,", req->type );
2410     fprintf( stderr, " flags=%d,", req->flags );
2411     fprintf( stderr, " win=%08x,", req->win );
2412     fprintf( stderr, " msg=%08x,", req->msg );
2413     fprintf( stderr, " wparam=" );
2414     dump_uint64( &req->wparam );
2415     fprintf( stderr, "," );
2416     fprintf( stderr, " lparam=" );
2417     dump_uint64( &req->lparam );
2418     fprintf( stderr, "," );
2419     fprintf( stderr, " timeout=" );
2420     dump_timeout( &req->timeout );
2421     fprintf( stderr, "," );
2422     fprintf( stderr, " data=" );
2423     dump_varargs_message_data( cur_size );
2424 }
2425
2426 static void dump_post_quit_message_request( const struct post_quit_message_request *req )
2427 {
2428     fprintf( stderr, " exit_code=%d", req->exit_code );
2429 }
2430
2431 static void dump_send_hardware_message_request( const struct send_hardware_message_request *req )
2432 {
2433     fprintf( stderr, " id=%04x,", req->id );
2434     fprintf( stderr, " win=%08x,", req->win );
2435     fprintf( stderr, " msg=%08x,", req->msg );
2436     fprintf( stderr, " wparam=" );
2437     dump_uint64( &req->wparam );
2438     fprintf( stderr, "," );
2439     fprintf( stderr, " lparam=" );
2440     dump_uint64( &req->lparam );
2441     fprintf( stderr, "," );
2442     fprintf( stderr, " info=" );
2443     dump_uint64( &req->info );
2444     fprintf( stderr, "," );
2445     fprintf( stderr, " x=%d,", req->x );
2446     fprintf( stderr, " y=%d,", req->y );
2447     fprintf( stderr, " time=%08x", req->time );
2448 }
2449
2450 static void dump_get_message_request( const struct get_message_request *req )
2451 {
2452     fprintf( stderr, " flags=%08x,", req->flags );
2453     fprintf( stderr, " get_win=%08x,", req->get_win );
2454     fprintf( stderr, " get_first=%08x,", req->get_first );
2455     fprintf( stderr, " get_last=%08x,", req->get_last );
2456     fprintf( stderr, " hw_id=%08x,", req->hw_id );
2457     fprintf( stderr, " wake_mask=%08x,", req->wake_mask );
2458     fprintf( stderr, " changed_mask=%08x", req->changed_mask );
2459 }
2460
2461 static void dump_get_message_reply( const struct get_message_reply *req )
2462 {
2463     fprintf( stderr, " win=%08x,", req->win );
2464     fprintf( stderr, " msg=%08x,", req->msg );
2465     fprintf( stderr, " wparam=" );
2466     dump_uint64( &req->wparam );
2467     fprintf( stderr, "," );
2468     fprintf( stderr, " lparam=" );
2469     dump_uint64( &req->lparam );
2470     fprintf( stderr, "," );
2471     fprintf( stderr, " type=%d,", req->type );
2472     fprintf( stderr, " time=%08x,", req->time );
2473     fprintf( stderr, " active_hooks=%08x,", req->active_hooks );
2474     fprintf( stderr, " total=%u,", req->total );
2475     fprintf( stderr, " data=" );
2476     dump_varargs_message_data( cur_size );
2477 }
2478
2479 static void dump_reply_message_request( const struct reply_message_request *req )
2480 {
2481     fprintf( stderr, " remove=%d,", req->remove );
2482     fprintf( stderr, " result=" );
2483     dump_uint64( &req->result );
2484     fprintf( stderr, "," );
2485     fprintf( stderr, " data=" );
2486     dump_varargs_bytes( cur_size );
2487 }
2488
2489 static void dump_accept_hardware_message_request( const struct accept_hardware_message_request *req )
2490 {
2491     fprintf( stderr, " hw_id=%08x,", req->hw_id );
2492     fprintf( stderr, " remove=%d,", req->remove );
2493     fprintf( stderr, " new_win=%08x", req->new_win );
2494 }
2495
2496 static void dump_get_message_reply_request( const struct get_message_reply_request *req )
2497 {
2498     fprintf( stderr, " cancel=%d", req->cancel );
2499 }
2500
2501 static void dump_get_message_reply_reply( const struct get_message_reply_reply *req )
2502 {
2503     fprintf( stderr, " result=" );
2504     dump_uint64( &req->result );
2505     fprintf( stderr, "," );
2506     fprintf( stderr, " data=" );
2507     dump_varargs_bytes( cur_size );
2508 }
2509
2510 static void dump_set_win_timer_request( const struct set_win_timer_request *req )
2511 {
2512     fprintf( stderr, " win=%08x,", req->win );
2513     fprintf( stderr, " msg=%08x,", req->msg );
2514     fprintf( stderr, " rate=%08x,", req->rate );
2515     fprintf( stderr, " id=" );
2516     dump_uint64( &req->id );
2517     fprintf( stderr, "," );
2518     fprintf( stderr, " lparam=" );
2519     dump_uint64( &req->lparam );
2520 }
2521
2522 static void dump_set_win_timer_reply( const struct set_win_timer_reply *req )
2523 {
2524     fprintf( stderr, " id=" );
2525     dump_uint64( &req->id );
2526 }
2527
2528 static void dump_kill_win_timer_request( const struct kill_win_timer_request *req )
2529 {
2530     fprintf( stderr, " win=%08x,", req->win );
2531     fprintf( stderr, " id=" );
2532     dump_uint64( &req->id );
2533     fprintf( stderr, "," );
2534     fprintf( stderr, " msg=%08x", req->msg );
2535 }
2536
2537 static void dump_is_window_hung_request( const struct is_window_hung_request *req )
2538 {
2539     fprintf( stderr, " win=%08x", req->win );
2540 }
2541
2542 static void dump_is_window_hung_reply( const struct is_window_hung_reply *req )
2543 {
2544     fprintf( stderr, " is_hung=%d", req->is_hung );
2545 }
2546
2547 static void dump_get_serial_info_request( const struct get_serial_info_request *req )
2548 {
2549     fprintf( stderr, " handle=%04x", req->handle );
2550 }
2551
2552 static void dump_get_serial_info_reply( const struct get_serial_info_reply *req )
2553 {
2554     fprintf( stderr, " readinterval=%08x,", req->readinterval );
2555     fprintf( stderr, " readconst=%08x,", req->readconst );
2556     fprintf( stderr, " readmult=%08x,", req->readmult );
2557     fprintf( stderr, " writeconst=%08x,", req->writeconst );
2558     fprintf( stderr, " writemult=%08x,", req->writemult );
2559     fprintf( stderr, " eventmask=%08x", req->eventmask );
2560 }
2561
2562 static void dump_set_serial_info_request( const struct set_serial_info_request *req )
2563 {
2564     fprintf( stderr, " handle=%04x,", req->handle );
2565     fprintf( stderr, " flags=%d,", req->flags );
2566     fprintf( stderr, " readinterval=%08x,", req->readinterval );
2567     fprintf( stderr, " readconst=%08x,", req->readconst );
2568     fprintf( stderr, " readmult=%08x,", req->readmult );
2569     fprintf( stderr, " writeconst=%08x,", req->writeconst );
2570     fprintf( stderr, " writemult=%08x,", req->writemult );
2571     fprintf( stderr, " eventmask=%08x", req->eventmask );
2572 }
2573
2574 static void dump_register_async_request( const struct register_async_request *req )
2575 {
2576     fprintf( stderr, " type=%d,", req->type );
2577     fprintf( stderr, " count=%d,", req->count );
2578     fprintf( stderr, " async=" );
2579     dump_async_data( &req->async );
2580 }
2581
2582 static void dump_cancel_async_request( const struct cancel_async_request *req )
2583 {
2584     fprintf( stderr, " handle=%04x", req->handle );
2585 }
2586
2587 static void dump_ioctl_request( const struct ioctl_request *req )
2588 {
2589     fprintf( stderr, " code=" );
2590     dump_ioctl_code( &req->code );
2591     fprintf( stderr, "," );
2592     fprintf( stderr, " async=" );
2593     dump_async_data( &req->async );
2594     fprintf( stderr, "," );
2595     fprintf( stderr, " blocking=%d,", req->blocking );
2596     fprintf( stderr, " in_data=" );
2597     dump_varargs_bytes( cur_size );
2598 }
2599
2600 static void dump_ioctl_reply( const struct ioctl_reply *req )
2601 {
2602     fprintf( stderr, " wait=%04x,", req->wait );
2603     fprintf( stderr, " options=%08x,", req->options );
2604     fprintf( stderr, " out_data=" );
2605     dump_varargs_bytes( cur_size );
2606 }
2607
2608 static void dump_get_ioctl_result_request( const struct get_ioctl_result_request *req )
2609 {
2610     fprintf( stderr, " handle=%04x,", req->handle );
2611     fprintf( stderr, " user_arg=%p", req->user_arg );
2612 }
2613
2614 static void dump_get_ioctl_result_reply( const struct get_ioctl_result_reply *req )
2615 {
2616     fprintf( stderr, " out_data=" );
2617     dump_varargs_bytes( cur_size );
2618 }
2619
2620 static void dump_create_named_pipe_request( const struct create_named_pipe_request *req )
2621 {
2622     fprintf( stderr, " access=%08x,", req->access );
2623     fprintf( stderr, " attributes=%08x,", req->attributes );
2624     fprintf( stderr, " rootdir=%04x,", req->rootdir );
2625     fprintf( stderr, " options=%08x,", req->options );
2626     fprintf( stderr, " flags=%08x,", req->flags );
2627     fprintf( stderr, " maxinstances=%08x,", req->maxinstances );
2628     fprintf( stderr, " outsize=%08x,", req->outsize );
2629     fprintf( stderr, " insize=%08x,", req->insize );
2630     fprintf( stderr, " timeout=" );
2631     dump_timeout( &req->timeout );
2632     fprintf( stderr, "," );
2633     fprintf( stderr, " name=" );
2634     dump_varargs_unicode_str( cur_size );
2635 }
2636
2637 static void dump_create_named_pipe_reply( const struct create_named_pipe_reply *req )
2638 {
2639     fprintf( stderr, " handle=%04x", req->handle );
2640 }
2641
2642 static void dump_get_named_pipe_info_request( const struct get_named_pipe_info_request *req )
2643 {
2644     fprintf( stderr, " handle=%04x", req->handle );
2645 }
2646
2647 static void dump_get_named_pipe_info_reply( const struct get_named_pipe_info_reply *req )
2648 {
2649     fprintf( stderr, " flags=%08x,", req->flags );
2650     fprintf( stderr, " maxinstances=%08x,", req->maxinstances );
2651     fprintf( stderr, " instances=%08x,", req->instances );
2652     fprintf( stderr, " outsize=%08x,", req->outsize );
2653     fprintf( stderr, " insize=%08x", req->insize );
2654 }
2655
2656 static void dump_create_window_request( const struct create_window_request *req )
2657 {
2658     fprintf( stderr, " parent=%08x,", req->parent );
2659     fprintf( stderr, " owner=%08x,", req->owner );
2660     fprintf( stderr, " atom=%04x,", req->atom );
2661     fprintf( stderr, " instance=" );
2662     dump_uint64( &req->instance );
2663     fprintf( stderr, "," );
2664     fprintf( stderr, " class=" );
2665     dump_varargs_unicode_str( cur_size );
2666 }
2667
2668 static void dump_create_window_reply( const struct create_window_reply *req )
2669 {
2670     fprintf( stderr, " handle=%08x,", req->handle );
2671     fprintf( stderr, " parent=%08x,", req->parent );
2672     fprintf( stderr, " owner=%08x,", req->owner );
2673     fprintf( stderr, " extra=%d,", req->extra );
2674     fprintf( stderr, " class_ptr=" );
2675     dump_uint64( &req->class_ptr );
2676 }
2677
2678 static void dump_destroy_window_request( const struct destroy_window_request *req )
2679 {
2680     fprintf( stderr, " handle=%08x", req->handle );
2681 }
2682
2683 static void dump_get_desktop_window_request( const struct get_desktop_window_request *req )
2684 {
2685     fprintf( stderr, " force=%d", req->force );
2686 }
2687
2688 static void dump_get_desktop_window_reply( const struct get_desktop_window_reply *req )
2689 {
2690     fprintf( stderr, " top_window=%08x,", req->top_window );
2691     fprintf( stderr, " msg_window=%08x", req->msg_window );
2692 }
2693
2694 static void dump_set_window_owner_request( const struct set_window_owner_request *req )
2695 {
2696     fprintf( stderr, " handle=%08x,", req->handle );
2697     fprintf( stderr, " owner=%08x", req->owner );
2698 }
2699
2700 static void dump_set_window_owner_reply( const struct set_window_owner_reply *req )
2701 {
2702     fprintf( stderr, " full_owner=%08x,", req->full_owner );
2703     fprintf( stderr, " prev_owner=%08x", req->prev_owner );
2704 }
2705
2706 static void dump_get_window_info_request( const struct get_window_info_request *req )
2707 {
2708     fprintf( stderr, " handle=%08x", req->handle );
2709 }
2710
2711 static void dump_get_window_info_reply( const struct get_window_info_reply *req )
2712 {
2713     fprintf( stderr, " full_handle=%08x,", req->full_handle );
2714     fprintf( stderr, " last_active=%08x,", req->last_active );
2715     fprintf( stderr, " pid=%04x,", req->pid );
2716     fprintf( stderr, " tid=%04x,", req->tid );
2717     fprintf( stderr, " atom=%04x,", req->atom );
2718     fprintf( stderr, " is_unicode=%d", req->is_unicode );
2719 }
2720
2721 static void dump_set_window_info_request( const struct set_window_info_request *req )
2722 {
2723     fprintf( stderr, " flags=%04x,", req->flags );
2724     fprintf( stderr, " is_unicode=%d,", req->is_unicode );
2725     fprintf( stderr, " handle=%08x,", req->handle );
2726     fprintf( stderr, " style=%08x,", req->style );
2727     fprintf( stderr, " ex_style=%08x,", req->ex_style );
2728     fprintf( stderr, " id=%08x,", req->id );
2729     fprintf( stderr, " instance=" );
2730     dump_uint64( &req->instance );
2731     fprintf( stderr, "," );
2732     fprintf( stderr, " user_data=" );
2733     dump_uint64( &req->user_data );
2734     fprintf( stderr, "," );
2735     fprintf( stderr, " extra_offset=%d,", req->extra_offset );
2736     fprintf( stderr, " extra_size=%u,", req->extra_size );
2737     fprintf( stderr, " extra_value=" );
2738     dump_uint64( &req->extra_value );
2739 }
2740
2741 static void dump_set_window_info_reply( const struct set_window_info_reply *req )
2742 {
2743     fprintf( stderr, " old_style=%08x,", req->old_style );
2744     fprintf( stderr, " old_ex_style=%08x,", req->old_ex_style );
2745     fprintf( stderr, " old_instance=" );
2746     dump_uint64( &req->old_instance );
2747     fprintf( stderr, "," );
2748     fprintf( stderr, " old_user_data=" );
2749     dump_uint64( &req->old_user_data );
2750     fprintf( stderr, "," );
2751     fprintf( stderr, " old_extra_value=" );
2752     dump_uint64( &req->old_extra_value );
2753     fprintf( stderr, "," );
2754     fprintf( stderr, " old_id=%08x", req->old_id );
2755 }
2756
2757 static void dump_set_parent_request( const struct set_parent_request *req )
2758 {
2759     fprintf( stderr, " handle=%08x,", req->handle );
2760     fprintf( stderr, " parent=%08x", req->parent );
2761 }
2762
2763 static void dump_set_parent_reply( const struct set_parent_reply *req )
2764 {
2765     fprintf( stderr, " old_parent=%08x,", req->old_parent );
2766     fprintf( stderr, " full_parent=%08x", req->full_parent );
2767 }
2768
2769 static void dump_get_window_parents_request( const struct get_window_parents_request *req )
2770 {
2771     fprintf( stderr, " handle=%08x", req->handle );
2772 }
2773
2774 static void dump_get_window_parents_reply( const struct get_window_parents_reply *req )
2775 {
2776     fprintf( stderr, " count=%d,", req->count );
2777     fprintf( stderr, " parents=" );
2778     dump_varargs_user_handles( cur_size );
2779 }
2780
2781 static void dump_get_window_children_request( const struct get_window_children_request *req )
2782 {
2783     fprintf( stderr, " desktop=%04x,", req->desktop );
2784     fprintf( stderr, " parent=%08x,", req->parent );
2785     fprintf( stderr, " atom=%04x,", req->atom );
2786     fprintf( stderr, " tid=%04x,", req->tid );
2787     fprintf( stderr, " class=" );
2788     dump_varargs_unicode_str( cur_size );
2789 }
2790
2791 static void dump_get_window_children_reply( const struct get_window_children_reply *req )
2792 {
2793     fprintf( stderr, " count=%d,", req->count );
2794     fprintf( stderr, " children=" );
2795     dump_varargs_user_handles( cur_size );
2796 }
2797
2798 static void dump_get_window_children_from_point_request( const struct get_window_children_from_point_request *req )
2799 {
2800     fprintf( stderr, " parent=%08x,", req->parent );
2801     fprintf( stderr, " x=%d,", req->x );
2802     fprintf( stderr, " y=%d", req->y );
2803 }
2804
2805 static void dump_get_window_children_from_point_reply( const struct get_window_children_from_point_reply *req )
2806 {
2807     fprintf( stderr, " count=%d,", req->count );
2808     fprintf( stderr, " children=" );
2809     dump_varargs_user_handles( cur_size );
2810 }
2811
2812 static void dump_get_window_tree_request( const struct get_window_tree_request *req )
2813 {
2814     fprintf( stderr, " handle=%08x", req->handle );
2815 }
2816
2817 static void dump_get_window_tree_reply( const struct get_window_tree_reply *req )
2818 {
2819     fprintf( stderr, " parent=%08x,", req->parent );
2820     fprintf( stderr, " owner=%08x,", req->owner );
2821     fprintf( stderr, " next_sibling=%08x,", req->next_sibling );
2822     fprintf( stderr, " prev_sibling=%08x,", req->prev_sibling );
2823     fprintf( stderr, " first_sibling=%08x,", req->first_sibling );
2824     fprintf( stderr, " last_sibling=%08x,", req->last_sibling );
2825     fprintf( stderr, " first_child=%08x,", req->first_child );
2826     fprintf( stderr, " last_child=%08x", req->last_child );
2827 }
2828
2829 static void dump_set_window_pos_request( const struct set_window_pos_request *req )
2830 {
2831     fprintf( stderr, " flags=%08x,", req->flags );
2832     fprintf( stderr, " handle=%08x,", req->handle );
2833     fprintf( stderr, " previous=%08x,", req->previous );
2834     fprintf( stderr, " window=" );
2835     dump_rectangle( &req->window );
2836     fprintf( stderr, "," );
2837     fprintf( stderr, " client=" );
2838     dump_rectangle( &req->client );
2839     fprintf( stderr, "," );
2840     fprintf( stderr, " valid=" );
2841     dump_varargs_rectangles( cur_size );
2842 }
2843
2844 static void dump_set_window_pos_reply( const struct set_window_pos_reply *req )
2845 {
2846     fprintf( stderr, " new_style=%08x,", req->new_style );
2847     fprintf( stderr, " new_ex_style=%08x", req->new_ex_style );
2848 }
2849
2850 static void dump_get_window_rectangles_request( const struct get_window_rectangles_request *req )
2851 {
2852     fprintf( stderr, " handle=%08x", req->handle );
2853 }
2854
2855 static void dump_get_window_rectangles_reply( const struct get_window_rectangles_reply *req )
2856 {
2857     fprintf( stderr, " window=" );
2858     dump_rectangle( &req->window );
2859     fprintf( stderr, "," );
2860     fprintf( stderr, " visible=" );
2861     dump_rectangle( &req->visible );
2862     fprintf( stderr, "," );
2863     fprintf( stderr, " client=" );
2864     dump_rectangle( &req->client );
2865 }
2866
2867 static void dump_get_window_text_request( const struct get_window_text_request *req )
2868 {
2869     fprintf( stderr, " handle=%08x", req->handle );
2870 }
2871
2872 static void dump_get_window_text_reply( const struct get_window_text_reply *req )
2873 {
2874     fprintf( stderr, " text=" );
2875     dump_varargs_unicode_str( cur_size );
2876 }
2877
2878 static void dump_set_window_text_request( const struct set_window_text_request *req )
2879 {
2880     fprintf( stderr, " handle=%08x,", req->handle );
2881     fprintf( stderr, " text=" );
2882     dump_varargs_unicode_str( cur_size );
2883 }
2884
2885 static void dump_get_windows_offset_request( const struct get_windows_offset_request *req )
2886 {
2887     fprintf( stderr, " from=%08x,", req->from );
2888     fprintf( stderr, " to=%08x", req->to );
2889 }
2890
2891 static void dump_get_windows_offset_reply( const struct get_windows_offset_reply *req )
2892 {
2893     fprintf( stderr, " x=%d,", req->x );
2894     fprintf( stderr, " y=%d", req->y );
2895 }
2896
2897 static void dump_get_visible_region_request( const struct get_visible_region_request *req )
2898 {
2899     fprintf( stderr, " window=%08x,", req->window );
2900     fprintf( stderr, " flags=%08x", req->flags );
2901 }
2902
2903 static void dump_get_visible_region_reply( const struct get_visible_region_reply *req )
2904 {
2905     fprintf( stderr, " top_win=%08x,", req->top_win );
2906     fprintf( stderr, " top_rect=" );
2907     dump_rectangle( &req->top_rect );
2908     fprintf( stderr, "," );
2909     fprintf( stderr, " win_rect=" );
2910     dump_rectangle( &req->win_rect );
2911     fprintf( stderr, "," );
2912     fprintf( stderr, " total_size=%u,", req->total_size );
2913     fprintf( stderr, " region=" );
2914     dump_varargs_rectangles( cur_size );
2915 }
2916
2917 static void dump_get_window_region_request( const struct get_window_region_request *req )
2918 {
2919     fprintf( stderr, " window=%08x", req->window );
2920 }
2921
2922 static void dump_get_window_region_reply( const struct get_window_region_reply *req )
2923 {
2924     fprintf( stderr, " total_size=%u,", req->total_size );
2925     fprintf( stderr, " region=" );
2926     dump_varargs_rectangles( cur_size );
2927 }
2928
2929 static void dump_set_window_region_request( const struct set_window_region_request *req )
2930 {
2931     fprintf( stderr, " window=%08x,", req->window );
2932     fprintf( stderr, " redraw=%d,", req->redraw );
2933     fprintf( stderr, " region=" );
2934     dump_varargs_rectangles( cur_size );
2935 }
2936
2937 static void dump_get_update_region_request( const struct get_update_region_request *req )
2938 {
2939     fprintf( stderr, " window=%08x,", req->window );
2940     fprintf( stderr, " from_child=%08x,", req->from_child );
2941     fprintf( stderr, " flags=%08x", req->flags );
2942 }
2943
2944 static void dump_get_update_region_reply( const struct get_update_region_reply *req )
2945 {
2946     fprintf( stderr, " child=%08x,", req->child );
2947     fprintf( stderr, " flags=%08x,", req->flags );
2948     fprintf( stderr, " total_size=%u,", req->total_size );
2949     fprintf( stderr, " region=" );
2950     dump_varargs_rectangles( cur_size );
2951 }
2952
2953 static void dump_update_window_zorder_request( const struct update_window_zorder_request *req )
2954 {
2955     fprintf( stderr, " window=%08x,", req->window );
2956     fprintf( stderr, " rect=" );
2957     dump_rectangle( &req->rect );
2958 }
2959
2960 static void dump_redraw_window_request( const struct redraw_window_request *req )
2961 {
2962     fprintf( stderr, " window=%08x,", req->window );
2963     fprintf( stderr, " flags=%08x,", req->flags );
2964     fprintf( stderr, " region=" );
2965     dump_varargs_rectangles( cur_size );
2966 }
2967
2968 static void dump_set_window_property_request( const struct set_window_property_request *req )
2969 {
2970     fprintf( stderr, " window=%08x,", req->window );
2971     fprintf( stderr, " data=" );
2972     dump_uint64( &req->data );
2973     fprintf( stderr, "," );
2974     fprintf( stderr, " atom=%04x,", req->atom );
2975     fprintf( stderr, " name=" );
2976     dump_varargs_unicode_str( cur_size );
2977 }
2978
2979 static void dump_remove_window_property_request( const struct remove_window_property_request *req )
2980 {
2981     fprintf( stderr, " window=%08x,", req->window );
2982     fprintf( stderr, " atom=%04x,", req->atom );
2983     fprintf( stderr, " name=" );
2984     dump_varargs_unicode_str( cur_size );
2985 }
2986
2987 static void dump_remove_window_property_reply( const struct remove_window_property_reply *req )
2988 {
2989     fprintf( stderr, " data=" );
2990     dump_uint64( &req->data );
2991 }
2992
2993 static void dump_get_window_property_request( const struct get_window_property_request *req )
2994 {
2995     fprintf( stderr, " window=%08x,", req->window );
2996     fprintf( stderr, " atom=%04x,", req->atom );
2997     fprintf( stderr, " name=" );
2998     dump_varargs_unicode_str( cur_size );
2999 }
3000
3001 static void dump_get_window_property_reply( const struct get_window_property_reply *req )
3002 {
3003     fprintf( stderr, " data=" );
3004     dump_uint64( &req->data );
3005 }
3006
3007 static void dump_get_window_properties_request( const struct get_window_properties_request *req )
3008 {
3009     fprintf( stderr, " window=%08x", req->window );
3010 }
3011
3012 static void dump_get_window_properties_reply( const struct get_window_properties_reply *req )
3013 {
3014     fprintf( stderr, " total=%d,", req->total );
3015     fprintf( stderr, " props=" );
3016     dump_varargs_properties( cur_size );
3017 }
3018
3019 static void dump_create_winstation_request( const struct create_winstation_request *req )
3020 {
3021     fprintf( stderr, " flags=%08x,", req->flags );
3022     fprintf( stderr, " access=%08x,", req->access );
3023     fprintf( stderr, " attributes=%08x,", req->attributes );
3024     fprintf( stderr, " name=" );
3025     dump_varargs_unicode_str( cur_size );
3026 }
3027
3028 static void dump_create_winstation_reply( const struct create_winstation_reply *req )
3029 {
3030     fprintf( stderr, " handle=%04x", req->handle );
3031 }
3032
3033 static void dump_open_winstation_request( const struct open_winstation_request *req )
3034 {
3035     fprintf( stderr, " access=%08x,", req->access );
3036     fprintf( stderr, " attributes=%08x,", req->attributes );
3037     fprintf( stderr, " name=" );
3038     dump_varargs_unicode_str( cur_size );
3039 }
3040
3041 static void dump_open_winstation_reply( const struct open_winstation_reply *req )
3042 {
3043     fprintf( stderr, " handle=%04x", req->handle );
3044 }
3045
3046 static void dump_close_winstation_request( const struct close_winstation_request *req )
3047 {
3048     fprintf( stderr, " handle=%04x", req->handle );
3049 }
3050
3051 static void dump_get_process_winstation_request( const struct get_process_winstation_request *req )
3052 {
3053 }
3054
3055 static void dump_get_process_winstation_reply( const struct get_process_winstation_reply *req )
3056 {
3057     fprintf( stderr, " handle=%04x", req->handle );
3058 }
3059
3060 static void dump_set_process_winstation_request( const struct set_process_winstation_request *req )
3061 {
3062     fprintf( stderr, " handle=%04x", req->handle );
3063 }
3064
3065 static void dump_enum_winstation_request( const struct enum_winstation_request *req )
3066 {
3067     fprintf( stderr, " index=%08x", req->index );
3068 }
3069
3070 static void dump_enum_winstation_reply( const struct enum_winstation_reply *req )
3071 {
3072     fprintf( stderr, " next=%08x,", req->next );
3073     fprintf( stderr, " name=" );
3074     dump_varargs_unicode_str( cur_size );
3075 }
3076
3077 static void dump_create_desktop_request( const struct create_desktop_request *req )
3078 {
3079     fprintf( stderr, " flags=%08x,", req->flags );
3080     fprintf( stderr, " access=%08x,", req->access );
3081     fprintf( stderr, " attributes=%08x,", req->attributes );
3082     fprintf( stderr, " name=" );
3083     dump_varargs_unicode_str( cur_size );
3084 }
3085
3086 static void dump_create_desktop_reply( const struct create_desktop_reply *req )
3087 {
3088     fprintf( stderr, " handle=%04x", req->handle );
3089 }
3090
3091 static void dump_open_desktop_request( const struct open_desktop_request *req )
3092 {
3093     fprintf( stderr, " winsta=%04x,", req->winsta );
3094     fprintf( stderr, " flags=%08x,", req->flags );
3095     fprintf( stderr, " access=%08x,", req->access );
3096     fprintf( stderr, " attributes=%08x,", req->attributes );
3097     fprintf( stderr, " name=" );
3098     dump_varargs_unicode_str( cur_size );
3099 }
3100
3101 static void dump_open_desktop_reply( const struct open_desktop_reply *req )
3102 {
3103     fprintf( stderr, " handle=%04x", req->handle );
3104 }
3105
3106 static void dump_close_desktop_request( const struct close_desktop_request *req )
3107 {
3108     fprintf( stderr, " handle=%04x", req->handle );
3109 }
3110
3111 static void dump_get_thread_desktop_request( const struct get_thread_desktop_request *req )
3112 {
3113     fprintf( stderr, " tid=%04x", req->tid );
3114 }
3115
3116 static void dump_get_thread_desktop_reply( const struct get_thread_desktop_reply *req )
3117 {
3118     fprintf( stderr, " handle=%04x", req->handle );
3119 }
3120
3121 static void dump_set_thread_desktop_request( const struct set_thread_desktop_request *req )
3122 {
3123     fprintf( stderr, " handle=%04x", req->handle );
3124 }
3125
3126 static void dump_enum_desktop_request( const struct enum_desktop_request *req )
3127 {
3128     fprintf( stderr, " winstation=%04x,", req->winstation );
3129     fprintf( stderr, " index=%08x", req->index );
3130 }
3131
3132 static void dump_enum_desktop_reply( const struct enum_desktop_reply *req )
3133 {
3134     fprintf( stderr, " next=%08x,", req->next );
3135     fprintf( stderr, " name=" );
3136     dump_varargs_unicode_str( cur_size );
3137 }
3138
3139 static void dump_set_user_object_info_request( const struct set_user_object_info_request *req )
3140 {
3141     fprintf( stderr, " handle=%04x,", req->handle );
3142     fprintf( stderr, " flags=%08x,", req->flags );
3143     fprintf( stderr, " obj_flags=%08x", req->obj_flags );
3144 }
3145
3146 static void dump_set_user_object_info_reply( const struct set_user_object_info_reply *req )
3147 {
3148     fprintf( stderr, " is_desktop=%d,", req->is_desktop );
3149     fprintf( stderr, " old_obj_flags=%08x,", req->old_obj_flags );
3150     fprintf( stderr, " name=" );
3151     dump_varargs_unicode_str( cur_size );
3152 }
3153
3154 static void dump_attach_thread_input_request( const struct attach_thread_input_request *req )
3155 {
3156     fprintf( stderr, " tid_from=%04x,", req->tid_from );
3157     fprintf( stderr, " tid_to=%04x,", req->tid_to );
3158     fprintf( stderr, " attach=%d", req->attach );
3159 }
3160
3161 static void dump_get_thread_input_request( const struct get_thread_input_request *req )
3162 {
3163     fprintf( stderr, " tid=%04x", req->tid );
3164 }
3165
3166 static void dump_get_thread_input_reply( const struct get_thread_input_reply *req )
3167 {
3168     fprintf( stderr, " focus=%08x,", req->focus );
3169     fprintf( stderr, " capture=%08x,", req->capture );
3170     fprintf( stderr, " active=%08x,", req->active );
3171     fprintf( stderr, " foreground=%08x,", req->foreground );
3172     fprintf( stderr, " menu_owner=%08x,", req->menu_owner );
3173     fprintf( stderr, " move_size=%08x,", req->move_size );
3174     fprintf( stderr, " caret=%08x,", req->caret );
3175     fprintf( stderr, " rect=" );
3176     dump_rectangle( &req->rect );
3177 }
3178
3179 static void dump_get_last_input_time_request( const struct get_last_input_time_request *req )
3180 {
3181 }
3182
3183 static void dump_get_last_input_time_reply( const struct get_last_input_time_reply *req )
3184 {
3185     fprintf( stderr, " time=%08x", req->time );
3186 }
3187
3188 static void dump_get_key_state_request( const struct get_key_state_request *req )
3189 {
3190     fprintf( stderr, " tid=%04x,", req->tid );
3191     fprintf( stderr, " key=%d", req->key );
3192 }
3193
3194 static void dump_get_key_state_reply( const struct get_key_state_reply *req )
3195 {
3196     fprintf( stderr, " state=%02x,", req->state );
3197     fprintf( stderr, " keystate=" );
3198     dump_varargs_bytes( cur_size );
3199 }
3200
3201 static void dump_set_key_state_request( const struct set_key_state_request *req )
3202 {
3203     fprintf( stderr, " tid=%04x,", req->tid );
3204     fprintf( stderr, " keystate=" );
3205     dump_varargs_bytes( cur_size );
3206 }
3207
3208 static void dump_set_foreground_window_request( const struct set_foreground_window_request *req )
3209 {
3210     fprintf( stderr, " handle=%08x", req->handle );
3211 }
3212
3213 static void dump_set_foreground_window_reply( const struct set_foreground_window_reply *req )
3214 {
3215     fprintf( stderr, " previous=%08x,", req->previous );
3216     fprintf( stderr, " send_msg_old=%d,", req->send_msg_old );
3217     fprintf( stderr, " send_msg_new=%d", req->send_msg_new );
3218 }
3219
3220 static void dump_set_focus_window_request( const struct set_focus_window_request *req )
3221 {
3222     fprintf( stderr, " handle=%08x", req->handle );
3223 }
3224
3225 static void dump_set_focus_window_reply( const struct set_focus_window_reply *req )
3226 {
3227     fprintf( stderr, " previous=%08x", req->previous );
3228 }
3229
3230 static void dump_set_active_window_request( const struct set_active_window_request *req )
3231 {
3232     fprintf( stderr, " handle=%08x", req->handle );
3233 }
3234
3235 static void dump_set_active_window_reply( const struct set_active_window_reply *req )
3236 {
3237     fprintf( stderr, " previous=%08x", req->previous );
3238 }
3239
3240 static void dump_set_capture_window_request( const struct set_capture_window_request *req )
3241 {
3242     fprintf( stderr, " handle=%08x,", req->handle );
3243     fprintf( stderr, " flags=%08x", req->flags );
3244 }
3245
3246 static void dump_set_capture_window_reply( const struct set_capture_window_reply *req )
3247 {
3248     fprintf( stderr, " previous=%08x,", req->previous );
3249     fprintf( stderr, " full_handle=%08x", req->full_handle );
3250 }
3251
3252 static void dump_set_caret_window_request( const struct set_caret_window_request *req )
3253 {
3254     fprintf( stderr, " handle=%08x,", req->handle );
3255     fprintf( stderr, " width=%d,", req->width );
3256     fprintf( stderr, " height=%d", req->height );
3257 }
3258
3259 static void dump_set_caret_window_reply( const struct set_caret_window_reply *req )
3260 {
3261     fprintf( stderr, " previous=%08x,", req->previous );
3262     fprintf( stderr, " old_rect=" );
3263     dump_rectangle( &req->old_rect );
3264     fprintf( stderr, "," );
3265     fprintf( stderr, " old_hide=%d,", req->old_hide );
3266     fprintf( stderr, " old_state=%d", req->old_state );
3267 }
3268
3269 static void dump_set_caret_info_request( const struct set_caret_info_request *req )
3270 {
3271     fprintf( stderr, " flags=%08x,", req->flags );
3272     fprintf( stderr, " handle=%08x,", req->handle );
3273     fprintf( stderr, " x=%d,", req->x );
3274     fprintf( stderr, " y=%d,", req->y );
3275     fprintf( stderr, " hide=%d,", req->hide );
3276     fprintf( stderr, " state=%d", req->state );
3277 }
3278
3279 static void dump_set_caret_info_reply( const struct set_caret_info_reply *req )
3280 {
3281     fprintf( stderr, " full_handle=%08x,", req->full_handle );
3282     fprintf( stderr, " old_rect=" );
3283     dump_rectangle( &req->old_rect );
3284     fprintf( stderr, "," );
3285     fprintf( stderr, " old_hide=%d,", req->old_hide );
3286     fprintf( stderr, " old_state=%d", req->old_state );
3287 }
3288
3289 static void dump_set_hook_request( const struct set_hook_request *req )
3290 {
3291     fprintf( stderr, " id=%d,", req->id );
3292     fprintf( stderr, " pid=%04x,", req->pid );
3293     fprintf( stderr, " tid=%04x,", req->tid );
3294     fprintf( stderr, " event_min=%d,", req->event_min );
3295     fprintf( stderr, " event_max=%d,", req->event_max );
3296     fprintf( stderr, " proc=" );
3297     dump_uint64( &req->proc );
3298     fprintf( stderr, "," );
3299     fprintf( stderr, " flags=%d,", req->flags );
3300     fprintf( stderr, " unicode=%d,", req->unicode );
3301     fprintf( stderr, " module=" );
3302     dump_varargs_unicode_str( cur_size );
3303 }
3304
3305 static void dump_set_hook_reply( const struct set_hook_reply *req )
3306 {
3307     fprintf( stderr, " handle=%08x,", req->handle );
3308     fprintf( stderr, " active_hooks=%08x", req->active_hooks );
3309 }
3310
3311 static void dump_remove_hook_request( const struct remove_hook_request *req )
3312 {
3313     fprintf( stderr, " handle=%08x,", req->handle );
3314     fprintf( stderr, " proc=" );
3315     dump_uint64( &req->proc );
3316     fprintf( stderr, "," );
3317     fprintf( stderr, " id=%d", req->id );
3318 }
3319
3320 static void dump_remove_hook_reply( const struct remove_hook_reply *req )
3321 {
3322     fprintf( stderr, " active_hooks=%08x", req->active_hooks );
3323 }
3324
3325 static void dump_start_hook_chain_request( const struct start_hook_chain_request *req )
3326 {
3327     fprintf( stderr, " id=%d,", req->id );
3328     fprintf( stderr, " event=%d,", req->event );
3329     fprintf( stderr, " window=%08x,", req->window );
3330     fprintf( stderr, " object_id=%d,", req->object_id );
3331     fprintf( stderr, " child_id=%d", req->child_id );
3332 }
3333
3334 static void dump_start_hook_chain_reply( const struct start_hook_chain_reply *req )
3335 {
3336     fprintf( stderr, " handle=%08x,", req->handle );
3337     fprintf( stderr, " pid=%04x,", req->pid );
3338     fprintf( stderr, " tid=%04x,", req->tid );
3339     fprintf( stderr, " unicode=%d,", req->unicode );
3340     fprintf( stderr, " proc=" );
3341     dump_uint64( &req->proc );
3342     fprintf( stderr, "," );
3343     fprintf( stderr, " active_hooks=%08x,", req->active_hooks );
3344     fprintf( stderr, " module=" );
3345     dump_varargs_unicode_str( cur_size );
3346 }
3347
3348 static void dump_finish_hook_chain_request( const struct finish_hook_chain_request *req )
3349 {
3350     fprintf( stderr, " id=%d", req->id );
3351 }
3352
3353 static void dump_get_hook_info_request( const struct get_hook_info_request *req )
3354 {
3355     fprintf( stderr, " handle=%08x,", req->handle );
3356     fprintf( stderr, " get_next=%d,", req->get_next );
3357     fprintf( stderr, " event=%d,", req->event );
3358     fprintf( stderr, " window=%08x,", req->window );
3359     fprintf( stderr, " object_id=%d,", req->object_id );
3360     fprintf( stderr, " child_id=%d", req->child_id );
3361 }
3362
3363 static void dump_get_hook_info_reply( const struct get_hook_info_reply *req )
3364 {
3365     fprintf( stderr, " handle=%08x,", req->handle );
3366     fprintf( stderr, " id=%d,", req->id );
3367     fprintf( stderr, " pid=%04x,", req->pid );
3368     fprintf( stderr, " tid=%04x,", req->tid );
3369     fprintf( stderr, " proc=" );
3370     dump_uint64( &req->proc );
3371     fprintf( stderr, "," );
3372     fprintf( stderr, " unicode=%d,", req->unicode );
3373     fprintf( stderr, " module=" );
3374     dump_varargs_unicode_str( cur_size );
3375 }
3376
3377 static void dump_create_class_request( const struct create_class_request *req )
3378 {
3379     fprintf( stderr, " local=%d,", req->local );
3380     fprintf( stderr, " atom=%04x,", req->atom );
3381     fprintf( stderr, " style=%08x,", req->style );
3382     fprintf( stderr, " instance=" );
3383     dump_uint64( &req->instance );
3384     fprintf( stderr, "," );
3385     fprintf( stderr, " extra=%d,", req->extra );
3386     fprintf( stderr, " win_extra=%d,", req->win_extra );
3387     fprintf( stderr, " client_ptr=" );
3388     dump_uint64( &req->client_ptr );
3389     fprintf( stderr, "," );
3390     fprintf( stderr, " name=" );
3391     dump_varargs_unicode_str( cur_size );
3392 }
3393
3394 static void dump_create_class_reply( const struct create_class_reply *req )
3395 {
3396     fprintf( stderr, " atom=%04x", req->atom );
3397 }
3398
3399 static void dump_destroy_class_request( const struct destroy_class_request *req )
3400 {
3401     fprintf( stderr, " atom=%04x,", req->atom );
3402     fprintf( stderr, " instance=" );
3403     dump_uint64( &req->instance );
3404     fprintf( stderr, "," );
3405     fprintf( stderr, " name=" );
3406     dump_varargs_unicode_str( cur_size );
3407 }
3408
3409 static void dump_destroy_class_reply( const struct destroy_class_reply *req )
3410 {
3411     fprintf( stderr, " client_ptr=" );
3412     dump_uint64( &req->client_ptr );
3413 }
3414
3415 static void dump_set_class_info_request( const struct set_class_info_request *req )
3416 {
3417     fprintf( stderr, " window=%08x,", req->window );
3418     fprintf( stderr, " flags=%08x,", req->flags );
3419     fprintf( stderr, " atom=%04x,", req->atom );
3420     fprintf( stderr, " style=%08x,", req->style );
3421     fprintf( stderr, " win_extra=%d,", req->win_extra );
3422     fprintf( stderr, " instance=" );
3423     dump_uint64( &req->instance );
3424     fprintf( stderr, "," );
3425     fprintf( stderr, " extra_offset=%d,", req->extra_offset );
3426     fprintf( stderr, " extra_size=%u,", req->extra_size );
3427     fprintf( stderr, " extra_value=" );
3428     dump_uint64( &req->extra_value );
3429 }
3430
3431 static void dump_set_class_info_reply( const struct set_class_info_reply *req )
3432 {
3433     fprintf( stderr, " old_atom=%04x,", req->old_atom );
3434     fprintf( stderr, " old_style=%08x,", req->old_style );
3435     fprintf( stderr, " old_extra=%d,", req->old_extra );
3436     fprintf( stderr, " old_win_extra=%d,", req->old_win_extra );
3437     fprintf( stderr, " old_instance=" );
3438     dump_uint64( &req->old_instance );
3439     fprintf( stderr, "," );
3440     fprintf( stderr, " old_extra_value=" );
3441     dump_uint64( &req->old_extra_value );
3442 }
3443
3444 static void dump_set_clipboard_info_request( const struct set_clipboard_info_request *req )
3445 {
3446     fprintf( stderr, " flags=%08x,", req->flags );
3447     fprintf( stderr, " clipboard=%08x,", req->clipboard );
3448     fprintf( stderr, " owner=%08x,", req->owner );
3449     fprintf( stderr, " viewer=%08x,", req->viewer );
3450     fprintf( stderr, " seqno=%08x", req->seqno );
3451 }
3452
3453 static void dump_set_clipboard_info_reply( const struct set_clipboard_info_reply *req )
3454 {
3455     fprintf( stderr, " flags=%08x,", req->flags );
3456     fprintf( stderr, " old_clipboard=%08x,", req->old_clipboard );
3457     fprintf( stderr, " old_owner=%08x,", req->old_owner );
3458     fprintf( stderr, " old_viewer=%08x,", req->old_viewer );
3459     fprintf( stderr, " seqno=%08x", req->seqno );
3460 }
3461
3462 static void dump_open_token_request( const struct open_token_request *req )
3463 {
3464     fprintf( stderr, " handle=%04x,", req->handle );
3465     fprintf( stderr, " access=%08x,", req->access );
3466     fprintf( stderr, " attributes=%08x,", req->attributes );
3467     fprintf( stderr, " flags=%08x", req->flags );
3468 }
3469
3470 static void dump_open_token_reply( const struct open_token_reply *req )
3471 {
3472     fprintf( stderr, " token=%04x", req->token );
3473 }
3474
3475 static void dump_set_global_windows_request( const struct set_global_windows_request *req )
3476 {
3477     fprintf( stderr, " flags=%08x,", req->flags );
3478     fprintf( stderr, " shell_window=%08x,", req->shell_window );
3479     fprintf( stderr, " shell_listview=%08x,", req->shell_listview );
3480     fprintf( stderr, " progman_window=%08x,", req->progman_window );
3481     fprintf( stderr, " taskman_window=%08x", req->taskman_window );
3482 }
3483
3484 static void dump_set_global_windows_reply( const struct set_global_windows_reply *req )
3485 {
3486     fprintf( stderr, " old_shell_window=%08x,", req->old_shell_window );
3487     fprintf( stderr, " old_shell_listview=%08x,", req->old_shell_listview );
3488     fprintf( stderr, " old_progman_window=%08x,", req->old_progman_window );
3489     fprintf( stderr, " old_taskman_window=%08x", req->old_taskman_window );
3490 }
3491
3492 static void dump_adjust_token_privileges_request( const struct adjust_token_privileges_request *req )
3493 {
3494     fprintf( stderr, " handle=%04x,", req->handle );
3495     fprintf( stderr, " disable_all=%d,", req->disable_all );
3496     fprintf( stderr, " get_modified_state=%d,", req->get_modified_state );
3497     fprintf( stderr, " privileges=" );
3498     dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
3499 }
3500
3501 static void dump_adjust_token_privileges_reply( const struct adjust_token_privileges_reply *req )
3502 {
3503     fprintf( stderr, " len=%08x,", req->len );
3504     fprintf( stderr, " privileges=" );
3505     dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
3506 }
3507
3508 static void dump_get_token_privileges_request( const struct get_token_privileges_request *req )
3509 {
3510     fprintf( stderr, " handle=%04x", req->handle );
3511 }
3512
3513 static void dump_get_token_privileges_reply( const struct get_token_privileges_reply *req )
3514 {
3515     fprintf( stderr, " len=%08x,", req->len );
3516     fprintf( stderr, " privileges=" );
3517     dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
3518 }
3519
3520 static void dump_check_token_privileges_request( const struct check_token_privileges_request *req )
3521 {
3522     fprintf( stderr, " handle=%04x,", req->handle );
3523     fprintf( stderr, " all_required=%d,", req->all_required );
3524     fprintf( stderr, " privileges=" );
3525     dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
3526 }
3527
3528 static void dump_check_token_privileges_reply( const struct check_token_privileges_reply *req )
3529 {
3530     fprintf( stderr, " has_privileges=%d,", req->has_privileges );
3531     fprintf( stderr, " privileges=" );
3532     dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
3533 }
3534
3535 static void dump_duplicate_token_request( const struct duplicate_token_request *req )
3536 {
3537     fprintf( stderr, " handle=%04x,", req->handle );
3538     fprintf( stderr, " access=%08x,", req->access );
3539     fprintf( stderr, " attributes=%08x,", req->attributes );
3540     fprintf( stderr, " primary=%d,", req->primary );
3541     fprintf( stderr, " impersonation_level=%d", req->impersonation_level );
3542 }
3543
3544 static void dump_duplicate_token_reply( const struct duplicate_token_reply *req )
3545 {
3546     fprintf( stderr, " new_handle=%04x", req->new_handle );
3547 }
3548
3549 static void dump_access_check_request( const struct access_check_request *req )
3550 {
3551     fprintf( stderr, " handle=%04x,", req->handle );
3552     fprintf( stderr, " desired_access=%08x,", req->desired_access );
3553     fprintf( stderr, " mapping_read=%08x,", req->mapping_read );
3554     fprintf( stderr, " mapping_write=%08x,", req->mapping_write );
3555     fprintf( stderr, " mapping_execute=%08x,", req->mapping_execute );
3556     fprintf( stderr, " mapping_all=%08x,", req->mapping_all );
3557     fprintf( stderr, " sd=" );
3558     dump_varargs_security_descriptor( cur_size );
3559 }
3560
3561 static void dump_access_check_reply( const struct access_check_reply *req )
3562 {
3563     fprintf( stderr, " access_granted=%08x,", req->access_granted );
3564     fprintf( stderr, " access_status=%08x,", req->access_status );
3565     fprintf( stderr, " privileges_len=%08x,", req->privileges_len );
3566     fprintf( stderr, " privileges=" );
3567     dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
3568 }
3569
3570 static void dump_get_token_user_request( const struct get_token_user_request *req )
3571 {
3572     fprintf( stderr, " handle=%04x", req->handle );
3573 }
3574
3575 static void dump_get_token_user_reply( const struct get_token_user_reply *req )
3576 {
3577     fprintf( stderr, " user_len=%u,", req->user_len );
3578     fprintf( stderr, " user=" );
3579     dump_varargs_SID( cur_size );
3580 }
3581
3582 static void dump_get_token_groups_request( const struct get_token_groups_request *req )
3583 {
3584     fprintf( stderr, " handle=%04x", req->handle );
3585 }
3586
3587 static void dump_get_token_groups_reply( const struct get_token_groups_reply *req )
3588 {
3589     fprintf( stderr, " user_len=%u,", req->user_len );
3590     fprintf( stderr, " user=" );
3591     dump_varargs_token_groups( cur_size );
3592 }
3593
3594 static void dump_set_security_object_request( const struct set_security_object_request *req )
3595 {
3596     fprintf( stderr, " handle=%04x,", req->handle );
3597     fprintf( stderr, " security_info=%08x,", req->security_info );
3598     fprintf( stderr, " sd=" );
3599     dump_varargs_security_descriptor( cur_size );
3600 }
3601
3602 static void dump_get_security_object_request( const struct get_security_object_request *req )
3603 {
3604     fprintf( stderr, " handle=%04x,", req->handle );
3605     fprintf( stderr, " security_info=%08x", req->security_info );
3606 }
3607
3608 static void dump_get_security_object_reply( const struct get_security_object_reply *req )
3609 {
3610     fprintf( stderr, " sd_len=%08x,", req->sd_len );
3611     fprintf( stderr, " sd=" );
3612     dump_varargs_security_descriptor( cur_size );
3613 }
3614
3615 static void dump_create_mailslot_request( const struct create_mailslot_request *req )
3616 {
3617     fprintf( stderr, " access=%08x,", req->access );
3618     fprintf( stderr, " attributes=%08x,", req->attributes );
3619     fprintf( stderr, " rootdir=%04x,", req->rootdir );
3620     fprintf( stderr, " max_msgsize=%08x,", req->max_msgsize );
3621     fprintf( stderr, " read_timeout=" );
3622     dump_timeout( &req->read_timeout );
3623     fprintf( stderr, "," );
3624     fprintf( stderr, " name=" );
3625     dump_varargs_unicode_str( cur_size );
3626 }
3627
3628 static void dump_create_mailslot_reply( const struct create_mailslot_reply *req )
3629 {
3630     fprintf( stderr, " handle=%04x", req->handle );
3631 }
3632
3633 static void dump_set_mailslot_info_request( const struct set_mailslot_info_request *req )
3634 {
3635     fprintf( stderr, " handle=%04x,", req->handle );
3636     fprintf( stderr, " flags=%08x,", req->flags );
3637     fprintf( stderr, " read_timeout=" );
3638     dump_timeout( &req->read_timeout );
3639 }
3640
3641 static void dump_set_mailslot_info_reply( const struct set_mailslot_info_reply *req )
3642 {
3643     fprintf( stderr, " max_msgsize=%08x,", req->max_msgsize );
3644     fprintf( stderr, " read_timeout=" );
3645     dump_timeout( &req->read_timeout );
3646 }
3647
3648 static void dump_create_directory_request( const struct create_directory_request *req )
3649 {
3650     fprintf( stderr, " access=%08x,", req->access );
3651     fprintf( stderr, " attributes=%08x,", req->attributes );
3652     fprintf( stderr, " rootdir=%04x,", req->rootdir );
3653     fprintf( stderr, " directory_name=" );
3654     dump_varargs_unicode_str( cur_size );
3655 }
3656
3657 static void dump_create_directory_reply( const struct create_directory_reply *req )
3658 {
3659     fprintf( stderr, " handle=%04x", req->handle );
3660 }
3661
3662 static void dump_open_directory_request( const struct open_directory_request *req )
3663 {
3664     fprintf( stderr, " access=%08x,", req->access );
3665     fprintf( stderr, " attributes=%08x,", req->attributes );
3666     fprintf( stderr, " rootdir=%04x,", req->rootdir );
3667     fprintf( stderr, " directory_name=" );
3668     dump_varargs_unicode_str( cur_size );
3669 }
3670
3671 static void dump_open_directory_reply( const struct open_directory_reply *req )
3672 {
3673     fprintf( stderr, " handle=%04x", req->handle );
3674 }
3675
3676 static void dump_get_directory_entry_request( const struct get_directory_entry_request *req )
3677 {
3678     fprintf( stderr, " handle=%04x,", req->handle );
3679     fprintf( stderr, " index=%08x", req->index );
3680 }
3681
3682 static void dump_get_directory_entry_reply( const struct get_directory_entry_reply *req )
3683 {
3684     fprintf( stderr, " name_len=%u,", req->name_len );
3685     fprintf( stderr, " name=" );
3686     dump_varargs_unicode_str( min(cur_size,req->name_len) );
3687     fputc( ',', stderr );
3688     fprintf( stderr, " type=" );
3689     dump_varargs_unicode_str( cur_size );
3690 }
3691
3692 static void dump_create_symlink_request( const struct create_symlink_request *req )
3693 {
3694     fprintf( stderr, " access=%08x,", req->access );
3695     fprintf( stderr, " attributes=%08x,", req->attributes );
3696     fprintf( stderr, " rootdir=%04x,", req->rootdir );
3697     fprintf( stderr, " name_len=%u,", req->name_len );
3698     fprintf( stderr, " name=" );
3699     dump_varargs_unicode_str( min(cur_size,req->name_len) );
3700     fputc( ',', stderr );
3701     fprintf( stderr, " target_name=" );
3702     dump_varargs_unicode_str( cur_size );
3703 }
3704
3705 static void dump_create_symlink_reply( const struct create_symlink_reply *req )
3706 {
3707     fprintf( stderr, " handle=%04x", req->handle );
3708 }
3709
3710 static void dump_open_symlink_request( const struct open_symlink_request *req )
3711 {
3712     fprintf( stderr, " access=%08x,", req->access );
3713     fprintf( stderr, " attributes=%08x,", req->attributes );
3714     fprintf( stderr, " rootdir=%04x,", req->rootdir );
3715     fprintf( stderr, " name=" );
3716     dump_varargs_unicode_str( cur_size );
3717 }
3718
3719 static void dump_open_symlink_reply( const struct open_symlink_reply *req )
3720 {
3721     fprintf( stderr, " handle=%04x", req->handle );
3722 }
3723
3724 static void dump_query_symlink_request( const struct query_symlink_request *req )
3725 {
3726     fprintf( stderr, " handle=%04x", req->handle );
3727 }
3728
3729 static void dump_query_symlink_reply( const struct query_symlink_reply *req )
3730 {
3731     fprintf( stderr, " target_name=" );
3732     dump_varargs_unicode_str( cur_size );
3733 }
3734
3735 static void dump_get_object_info_request( const struct get_object_info_request *req )
3736 {
3737     fprintf( stderr, " handle=%04x", req->handle );
3738 }
3739
3740 static void dump_get_object_info_reply( const struct get_object_info_reply *req )
3741 {
3742     fprintf( stderr, " access=%08x,", req->access );
3743     fprintf( stderr, " ref_count=%08x", req->ref_count );
3744 }
3745
3746 static void dump_unlink_object_request( const struct unlink_object_request *req )
3747 {
3748     fprintf( stderr, " handle=%04x", req->handle );
3749 }
3750
3751 static void dump_get_token_impersonation_level_request( const struct get_token_impersonation_level_request *req )
3752 {
3753     fprintf( stderr, " handle=%04x", req->handle );
3754 }
3755
3756 static void dump_get_token_impersonation_level_reply( const struct get_token_impersonation_level_reply *req )
3757 {
3758     fprintf( stderr, " impersonation_level=%d", req->impersonation_level );
3759 }
3760
3761 static void dump_allocate_locally_unique_id_request( const struct allocate_locally_unique_id_request *req )
3762 {
3763 }
3764
3765 static void dump_allocate_locally_unique_id_reply( const struct allocate_locally_unique_id_reply *req )
3766 {
3767     fprintf( stderr, " luid=" );
3768     dump_luid( &req->luid );
3769 }
3770
3771 static void dump_create_device_manager_request( const struct create_device_manager_request *req )
3772 {
3773     fprintf( stderr, " access=%08x,", req->access );
3774     fprintf( stderr, " attributes=%08x", req->attributes );
3775 }
3776
3777 static void dump_create_device_manager_reply( const struct create_device_manager_reply *req )
3778 {
3779     fprintf( stderr, " handle=%04x", req->handle );
3780 }
3781
3782 static void dump_create_device_request( const struct create_device_request *req )
3783 {
3784     fprintf( stderr, " access=%08x,", req->access );
3785     fprintf( stderr, " attributes=%08x,", req->attributes );
3786     fprintf( stderr, " rootdir=%04x,", req->rootdir );
3787     fprintf( stderr, " manager=%04x,", req->manager );
3788     fprintf( stderr, " user_ptr=" );
3789     dump_uint64( &req->user_ptr );
3790     fprintf( stderr, "," );
3791     fprintf( stderr, " name=" );
3792     dump_varargs_unicode_str( cur_size );
3793 }
3794
3795 static void dump_create_device_reply( const struct create_device_reply *req )
3796 {
3797     fprintf( stderr, " handle=%04x", req->handle );
3798 }
3799
3800 static void dump_delete_device_request( const struct delete_device_request *req )
3801 {
3802     fprintf( stderr, " handle=%04x", req->handle );
3803 }
3804
3805 static void dump_get_next_device_request_request( const struct get_next_device_request_request *req )
3806 {
3807     fprintf( stderr, " manager=%04x,", req->manager );
3808     fprintf( stderr, " prev=%04x,", req->prev );
3809     fprintf( stderr, " status=%08x,", req->status );
3810     fprintf( stderr, " prev_data=" );
3811     dump_varargs_bytes( cur_size );
3812 }
3813
3814 static void dump_get_next_device_request_reply( const struct get_next_device_request_reply *req )
3815 {
3816     fprintf( stderr, " next=%04x,", req->next );
3817     fprintf( stderr, " code=" );
3818     dump_ioctl_code( &req->code );
3819     fprintf( stderr, "," );
3820     fprintf( stderr, " user_ptr=" );
3821     dump_uint64( &req->user_ptr );
3822     fprintf( stderr, "," );
3823     fprintf( stderr, " in_size=%u,", req->in_size );
3824     fprintf( stderr, " out_size=%u,", req->out_size );
3825     fprintf( stderr, " next_data=" );
3826     dump_varargs_bytes( cur_size );
3827 }
3828
3829 static void dump_make_process_system_request( const struct make_process_system_request *req )
3830 {
3831 }
3832
3833 static void dump_make_process_system_reply( const struct make_process_system_reply *req )
3834 {
3835     fprintf( stderr, " event=%04x", req->event );
3836 }
3837
3838 static void dump_get_token_statistics_request( const struct get_token_statistics_request *req )
3839 {
3840     fprintf( stderr, " handle=%04x", req->handle );
3841 }
3842
3843 static void dump_get_token_statistics_reply( const struct get_token_statistics_reply *req )
3844 {
3845     fprintf( stderr, " token_id=" );
3846     dump_luid( &req->token_id );
3847     fprintf( stderr, "," );
3848     fprintf( stderr, " modified_id=" );
3849     dump_luid( &req->modified_id );
3850     fprintf( stderr, "," );
3851     fprintf( stderr, " primary=%d,", req->primary );
3852     fprintf( stderr, " impersonation_level=%d,", req->impersonation_level );
3853     fprintf( stderr, " group_count=%d,", req->group_count );
3854     fprintf( stderr, " privilege_count=%d", req->privilege_count );
3855 }
3856
3857 static void dump_create_completion_request( const struct create_completion_request *req )
3858 {
3859     fprintf( stderr, " access=%08x,", req->access );
3860     fprintf( stderr, " attributes=%08x,", req->attributes );
3861     fprintf( stderr, " concurrent=%08x,", req->concurrent );
3862     fprintf( stderr, " rootdir=%04x,", req->rootdir );
3863     fprintf( stderr, " filename=" );
3864     dump_varargs_string( cur_size );
3865 }
3866
3867 static void dump_create_completion_reply( const struct create_completion_reply *req )
3868 {
3869     fprintf( stderr, " handle=%04x", req->handle );
3870 }
3871
3872 static void dump_open_completion_request( const struct open_completion_request *req )
3873 {
3874     fprintf( stderr, " access=%08x,", req->access );
3875     fprintf( stderr, " attributes=%08x,", req->attributes );
3876     fprintf( stderr, " rootdir=%04x,", req->rootdir );
3877     fprintf( stderr, " filename=" );
3878     dump_varargs_string( cur_size );
3879 }
3880
3881 static void dump_open_completion_reply( const struct open_completion_reply *req )
3882 {
3883     fprintf( stderr, " handle=%04x", req->handle );
3884 }
3885
3886 static void dump_add_completion_request( const struct add_completion_request *req )
3887 {
3888     fprintf( stderr, " handle=%04x,", req->handle );
3889     fprintf( stderr, " ckey=" );
3890     dump_uint64( &req->ckey );
3891     fprintf( stderr, "," );
3892     fprintf( stderr, " cvalue=" );
3893     dump_uint64( &req->cvalue );
3894     fprintf( stderr, "," );
3895     fprintf( stderr, " information=%08x,", req->information );
3896     fprintf( stderr, " status=%08x", req->status );
3897 }
3898
3899 static void dump_remove_completion_request( const struct remove_completion_request *req )
3900 {
3901     fprintf( stderr, " handle=%04x", req->handle );
3902 }
3903
3904 static void dump_remove_completion_reply( const struct remove_completion_reply *req )
3905 {
3906     fprintf( stderr, " ckey=" );
3907     dump_uint64( &req->ckey );
3908     fprintf( stderr, "," );
3909     fprintf( stderr, " cvalue=" );
3910     dump_uint64( &req->cvalue );
3911     fprintf( stderr, "," );
3912     fprintf( stderr, " information=%08x,", req->information );
3913     fprintf( stderr, " status=%08x", req->status );
3914 }
3915
3916 static void dump_query_completion_request( const struct query_completion_request *req )
3917 {
3918     fprintf( stderr, " handle=%04x", req->handle );
3919 }
3920
3921 static void dump_query_completion_reply( const struct query_completion_reply *req )
3922 {
3923     fprintf( stderr, " depth=%08x", req->depth );
3924 }
3925
3926 static void dump_set_completion_info_request( const struct set_completion_info_request *req )
3927 {
3928     fprintf( stderr, " handle=%04x,", req->handle );
3929     fprintf( stderr, " chandle=%04x,", req->chandle );
3930     fprintf( stderr, " ckey=" );
3931     dump_uint64( &req->ckey );
3932 }
3933
3934 static void dump_add_fd_completion_request( const struct add_fd_completion_request *req )
3935 {
3936     fprintf( stderr, " handle=%04x,", req->handle );
3937     fprintf( stderr, " cvalue=" );
3938     dump_uint64( &req->cvalue );
3939     fprintf( stderr, "," );
3940     fprintf( stderr, " status=%08x,", req->status );
3941     fprintf( stderr, " information=%08x", req->information );
3942 }
3943
3944 static void dump_get_window_layered_info_request( const struct get_window_layered_info_request *req )
3945 {
3946     fprintf( stderr, " handle=%08x", req->handle );
3947 }
3948
3949 static void dump_get_window_layered_info_reply( const struct get_window_layered_info_reply *req )
3950 {
3951     fprintf( stderr, " color_key=%08x,", req->color_key );
3952     fprintf( stderr, " alpha=%08x,", req->alpha );
3953     fprintf( stderr, " flags=%08x", req->flags );
3954 }
3955
3956 static void dump_set_window_layered_info_request( const struct set_window_layered_info_request *req )
3957 {
3958     fprintf( stderr, " handle=%08x,", req->handle );
3959     fprintf( stderr, " color_key=%08x,", req->color_key );
3960     fprintf( stderr, " alpha=%08x,", req->alpha );
3961     fprintf( stderr, " flags=%08x", req->flags );
3962 }
3963
3964 static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
3965     (dump_func)dump_new_process_request,
3966     (dump_func)dump_get_new_process_info_request,
3967     (dump_func)dump_new_thread_request,
3968     (dump_func)dump_get_startup_info_request,
3969     (dump_func)dump_init_process_done_request,
3970     (dump_func)dump_init_thread_request,
3971     (dump_func)dump_terminate_process_request,
3972     (dump_func)dump_terminate_thread_request,
3973     (dump_func)dump_get_process_info_request,
3974     (dump_func)dump_set_process_info_request,
3975     (dump_func)dump_get_thread_info_request,
3976     (dump_func)dump_set_thread_info_request,
3977     (dump_func)dump_get_dll_info_request,
3978     (dump_func)dump_suspend_thread_request,
3979     (dump_func)dump_resume_thread_request,
3980     (dump_func)dump_load_dll_request,
3981     (dump_func)dump_unload_dll_request,
3982     (dump_func)dump_queue_apc_request,
3983     (dump_func)dump_get_apc_result_request,
3984     (dump_func)dump_close_handle_request,
3985     (dump_func)dump_set_handle_info_request,
3986     (dump_func)dump_dup_handle_request,
3987     (dump_func)dump_open_process_request,
3988     (dump_func)dump_open_thread_request,
3989     (dump_func)dump_select_request,
3990     (dump_func)dump_create_event_request,
3991     (dump_func)dump_event_op_request,
3992     (dump_func)dump_open_event_request,
3993     (dump_func)dump_create_mutex_request,
3994     (dump_func)dump_release_mutex_request,
3995     (dump_func)dump_open_mutex_request,
3996     (dump_func)dump_create_semaphore_request,
3997     (dump_func)dump_release_semaphore_request,
3998     (dump_func)dump_open_semaphore_request,
3999     (dump_func)dump_create_file_request,
4000     (dump_func)dump_open_file_object_request,
4001     (dump_func)dump_alloc_file_handle_request,
4002     (dump_func)dump_get_handle_fd_request,
4003     (dump_func)dump_flush_file_request,
4004     (dump_func)dump_lock_file_request,
4005     (dump_func)dump_unlock_file_request,
4006     (dump_func)dump_create_socket_request,
4007     (dump_func)dump_accept_socket_request,
4008     (dump_func)dump_set_socket_event_request,
4009     (dump_func)dump_get_socket_event_request,
4010     (dump_func)dump_enable_socket_event_request,
4011     (dump_func)dump_set_socket_deferred_request,
4012     (dump_func)dump_alloc_console_request,
4013     (dump_func)dump_free_console_request,
4014     (dump_func)dump_get_console_renderer_events_request,
4015     (dump_func)dump_open_console_request,
4016     (dump_func)dump_get_console_wait_event_request,
4017     (dump_func)dump_get_console_mode_request,
4018     (dump_func)dump_set_console_mode_request,
4019     (dump_func)dump_set_console_input_info_request,
4020     (dump_func)dump_get_console_input_info_request,
4021     (dump_func)dump_append_console_input_history_request,
4022     (dump_func)dump_get_console_input_history_request,
4023     (dump_func)dump_create_console_output_request,
4024     (dump_func)dump_set_console_output_info_request,
4025     (dump_func)dump_get_console_output_info_request,
4026     (dump_func)dump_write_console_input_request,
4027     (dump_func)dump_read_console_input_request,
4028     (dump_func)dump_write_console_output_request,
4029     (dump_func)dump_fill_console_output_request,
4030     (dump_func)dump_read_console_output_request,
4031     (dump_func)dump_move_console_output_request,
4032     (dump_func)dump_send_console_signal_request,
4033     (dump_func)dump_read_directory_changes_request,
4034     (dump_func)dump_read_change_request,
4035     (dump_func)dump_create_mapping_request,
4036     (dump_func)dump_open_mapping_request,
4037     (dump_func)dump_get_mapping_info_request,
4038     (dump_func)dump_get_mapping_committed_range_request,
4039     (dump_func)dump_add_mapping_committed_range_request,
4040     (dump_func)dump_create_snapshot_request,
4041     (dump_func)dump_next_process_request,
4042     (dump_func)dump_next_thread_request,
4043     (dump_func)dump_wait_debug_event_request,
4044     (dump_func)dump_queue_exception_event_request,
4045     (dump_func)dump_get_exception_status_request,
4046     (dump_func)dump_output_debug_string_request,
4047     (dump_func)dump_continue_debug_event_request,
4048     (dump_func)dump_debug_process_request,
4049     (dump_func)dump_debug_break_request,
4050     (dump_func)dump_set_debugger_kill_on_exit_request,
4051     (dump_func)dump_read_process_memory_request,
4052     (dump_func)dump_write_process_memory_request,
4053     (dump_func)dump_create_key_request,
4054     (dump_func)dump_open_key_request,
4055     (dump_func)dump_delete_key_request,
4056     (dump_func)dump_flush_key_request,
4057     (dump_func)dump_enum_key_request,
4058     (dump_func)dump_set_key_value_request,
4059     (dump_func)dump_get_key_value_request,
4060     (dump_func)dump_enum_key_value_request,
4061     (dump_func)dump_delete_key_value_request,
4062     (dump_func)dump_load_registry_request,
4063     (dump_func)dump_unload_registry_request,
4064     (dump_func)dump_save_registry_request,
4065     (dump_func)dump_set_registry_notification_request,
4066     (dump_func)dump_create_timer_request,
4067     (dump_func)dump_open_timer_request,
4068     (dump_func)dump_set_timer_request,
4069     (dump_func)dump_cancel_timer_request,
4070     (dump_func)dump_get_timer_info_request,
4071     (dump_func)dump_get_thread_context_request,
4072     (dump_func)dump_set_thread_context_request,
4073     (dump_func)dump_get_selector_entry_request,
4074     (dump_func)dump_add_atom_request,
4075     (dump_func)dump_delete_atom_request,
4076     (dump_func)dump_find_atom_request,
4077     (dump_func)dump_get_atom_information_request,
4078     (dump_func)dump_set_atom_information_request,
4079     (dump_func)dump_empty_atom_table_request,
4080     (dump_func)dump_init_atom_table_request,
4081     (dump_func)dump_get_msg_queue_request,
4082     (dump_func)dump_set_queue_fd_request,
4083     (dump_func)dump_set_queue_mask_request,
4084     (dump_func)dump_get_queue_status_request,
4085     (dump_func)dump_get_process_idle_event_request,
4086     (dump_func)dump_send_message_request,
4087     (dump_func)dump_post_quit_message_request,
4088     (dump_func)dump_send_hardware_message_request,
4089     (dump_func)dump_get_message_request,
4090     (dump_func)dump_reply_message_request,
4091     (dump_func)dump_accept_hardware_message_request,
4092     (dump_func)dump_get_message_reply_request,
4093     (dump_func)dump_set_win_timer_request,
4094     (dump_func)dump_kill_win_timer_request,
4095     (dump_func)dump_is_window_hung_request,
4096     (dump_func)dump_get_serial_info_request,
4097     (dump_func)dump_set_serial_info_request,
4098     (dump_func)dump_register_async_request,
4099     (dump_func)dump_cancel_async_request,
4100     (dump_func)dump_ioctl_request,
4101     (dump_func)dump_get_ioctl_result_request,
4102     (dump_func)dump_create_named_pipe_request,
4103     (dump_func)dump_get_named_pipe_info_request,
4104     (dump_func)dump_create_window_request,
4105     (dump_func)dump_destroy_window_request,
4106     (dump_func)dump_get_desktop_window_request,
4107     (dump_func)dump_set_window_owner_request,
4108     (dump_func)dump_get_window_info_request,
4109     (dump_func)dump_set_window_info_request,
4110     (dump_func)dump_set_parent_request,
4111     (dump_func)dump_get_window_parents_request,
4112     (dump_func)dump_get_window_children_request,
4113     (dump_func)dump_get_window_children_from_point_request,
4114     (dump_func)dump_get_window_tree_request,
4115     (dump_func)dump_set_window_pos_request,
4116     (dump_func)dump_get_window_rectangles_request,
4117     (dump_func)dump_get_window_text_request,
4118     (dump_func)dump_set_window_text_request,
4119     (dump_func)dump_get_windows_offset_request,
4120     (dump_func)dump_get_visible_region_request,
4121     (dump_func)dump_get_window_region_request,
4122     (dump_func)dump_set_window_region_request,
4123     (dump_func)dump_get_update_region_request,
4124     (dump_func)dump_update_window_zorder_request,
4125     (dump_func)dump_redraw_window_request,
4126     (dump_func)dump_set_window_property_request,
4127     (dump_func)dump_remove_window_property_request,
4128     (dump_func)dump_get_window_property_request,
4129     (dump_func)dump_get_window_properties_request,
4130     (dump_func)dump_create_winstation_request,
4131     (dump_func)dump_open_winstation_request,
4132     (dump_func)dump_close_winstation_request,
4133     (dump_func)dump_get_process_winstation_request,
4134     (dump_func)dump_set_process_winstation_request,
4135     (dump_func)dump_enum_winstation_request,
4136     (dump_func)dump_create_desktop_request,
4137     (dump_func)dump_open_desktop_request,
4138     (dump_func)dump_close_desktop_request,
4139     (dump_func)dump_get_thread_desktop_request,
4140     (dump_func)dump_set_thread_desktop_request,
4141     (dump_func)dump_enum_desktop_request,
4142     (dump_func)dump_set_user_object_info_request,
4143     (dump_func)dump_attach_thread_input_request,
4144     (dump_func)dump_get_thread_input_request,
4145     (dump_func)dump_get_last_input_time_request,
4146     (dump_func)dump_get_key_state_request,
4147     (dump_func)dump_set_key_state_request,
4148     (dump_func)dump_set_foreground_window_request,
4149     (dump_func)dump_set_focus_window_request,
4150     (dump_func)dump_set_active_window_request,
4151     (dump_func)dump_set_capture_window_request,
4152     (dump_func)dump_set_caret_window_request,
4153     (dump_func)dump_set_caret_info_request,
4154     (dump_func)dump_set_hook_request,
4155     (dump_func)dump_remove_hook_request,
4156     (dump_func)dump_start_hook_chain_request,
4157     (dump_func)dump_finish_hook_chain_request,
4158     (dump_func)dump_get_hook_info_request,
4159     (dump_func)dump_create_class_request,
4160     (dump_func)dump_destroy_class_request,
4161     (dump_func)dump_set_class_info_request,
4162     (dump_func)dump_set_clipboard_info_request,
4163     (dump_func)dump_open_token_request,
4164     (dump_func)dump_set_global_windows_request,
4165     (dump_func)dump_adjust_token_privileges_request,
4166     (dump_func)dump_get_token_privileges_request,
4167     (dump_func)dump_check_token_privileges_request,
4168     (dump_func)dump_duplicate_token_request,
4169     (dump_func)dump_access_check_request,
4170     (dump_func)dump_get_token_user_request,
4171     (dump_func)dump_get_token_groups_request,
4172     (dump_func)dump_set_security_object_request,
4173     (dump_func)dump_get_security_object_request,
4174     (dump_func)dump_create_mailslot_request,
4175     (dump_func)dump_set_mailslot_info_request,
4176     (dump_func)dump_create_directory_request,
4177     (dump_func)dump_open_directory_request,
4178     (dump_func)dump_get_directory_entry_request,
4179     (dump_func)dump_create_symlink_request,
4180     (dump_func)dump_open_symlink_request,
4181     (dump_func)dump_query_symlink_request,
4182     (dump_func)dump_get_object_info_request,
4183     (dump_func)dump_unlink_object_request,
4184     (dump_func)dump_get_token_impersonation_level_request,
4185     (dump_func)dump_allocate_locally_unique_id_request,
4186     (dump_func)dump_create_device_manager_request,
4187     (dump_func)dump_create_device_request,
4188     (dump_func)dump_delete_device_request,
4189     (dump_func)dump_get_next_device_request_request,
4190     (dump_func)dump_make_process_system_request,
4191     (dump_func)dump_get_token_statistics_request,
4192     (dump_func)dump_create_completion_request,
4193     (dump_func)dump_open_completion_request,
4194     (dump_func)dump_add_completion_request,
4195     (dump_func)dump_remove_completion_request,
4196     (dump_func)dump_query_completion_request,
4197     (dump_func)dump_set_completion_info_request,
4198     (dump_func)dump_add_fd_completion_request,
4199     (dump_func)dump_get_window_layered_info_request,
4200     (dump_func)dump_set_window_layered_info_request,
4201 };
4202
4203 static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
4204     (dump_func)dump_new_process_reply,
4205     (dump_func)dump_get_new_process_info_reply,
4206     (dump_func)dump_new_thread_reply,
4207     (dump_func)dump_get_startup_info_reply,
4208     NULL,
4209     (dump_func)dump_init_thread_reply,
4210     (dump_func)dump_terminate_process_reply,
4211     (dump_func)dump_terminate_thread_reply,
4212     (dump_func)dump_get_process_info_reply,
4213     NULL,
4214     (dump_func)dump_get_thread_info_reply,
4215     NULL,
4216     (dump_func)dump_get_dll_info_reply,
4217     (dump_func)dump_suspend_thread_reply,
4218     (dump_func)dump_resume_thread_reply,
4219     NULL,
4220     NULL,
4221     (dump_func)dump_queue_apc_reply,
4222     (dump_func)dump_get_apc_result_reply,
4223     NULL,
4224     (dump_func)dump_set_handle_info_reply,
4225     (dump_func)dump_dup_handle_reply,
4226     (dump_func)dump_open_process_reply,
4227     (dump_func)dump_open_thread_reply,
4228     (dump_func)dump_select_reply,
4229     (dump_func)dump_create_event_reply,
4230     NULL,
4231     (dump_func)dump_open_event_reply,
4232     (dump_func)dump_create_mutex_reply,
4233     (dump_func)dump_release_mutex_reply,
4234     (dump_func)dump_open_mutex_reply,
4235     (dump_func)dump_create_semaphore_reply,
4236     (dump_func)dump_release_semaphore_reply,
4237     (dump_func)dump_open_semaphore_reply,
4238     (dump_func)dump_create_file_reply,
4239     (dump_func)dump_open_file_object_reply,
4240     (dump_func)dump_alloc_file_handle_reply,
4241     (dump_func)dump_get_handle_fd_reply,
4242     (dump_func)dump_flush_file_reply,
4243     (dump_func)dump_lock_file_reply,
4244     NULL,
4245     (dump_func)dump_create_socket_reply,
4246     (dump_func)dump_accept_socket_reply,
4247     NULL,
4248     (dump_func)dump_get_socket_event_reply,
4249     NULL,
4250     NULL,
4251     (dump_func)dump_alloc_console_reply,
4252     NULL,
4253     (dump_func)dump_get_console_renderer_events_reply,
4254     (dump_func)dump_open_console_reply,
4255     (dump_func)dump_get_console_wait_event_reply,
4256     (dump_func)dump_get_console_mode_reply,
4257     NULL,
4258     NULL,
4259     (dump_func)dump_get_console_input_info_reply,
4260     NULL,
4261     (dump_func)dump_get_console_input_history_reply,
4262     (dump_func)dump_create_console_output_reply,
4263     NULL,
4264     (dump_func)dump_get_console_output_info_reply,
4265     (dump_func)dump_write_console_input_reply,
4266     (dump_func)dump_read_console_input_reply,
4267     (dump_func)dump_write_console_output_reply,
4268     (dump_func)dump_fill_console_output_reply,
4269     (dump_func)dump_read_console_output_reply,
4270     NULL,
4271     NULL,
4272     NULL,
4273     (dump_func)dump_read_change_reply,
4274     (dump_func)dump_create_mapping_reply,
4275     (dump_func)dump_open_mapping_reply,
4276     (dump_func)dump_get_mapping_info_reply,
4277     (dump_func)dump_get_mapping_committed_range_reply,
4278     NULL,
4279     (dump_func)dump_create_snapshot_reply,
4280     (dump_func)dump_next_process_reply,
4281     (dump_func)dump_next_thread_reply,
4282     (dump_func)dump_wait_debug_event_reply,
4283     (dump_func)dump_queue_exception_event_reply,
4284     (dump_func)dump_get_exception_status_reply,
4285     NULL,
4286     NULL,
4287     NULL,
4288     (dump_func)dump_debug_break_reply,
4289     NULL,
4290     (dump_func)dump_read_process_memory_reply,
4291     NULL,
4292     (dump_func)dump_create_key_reply,
4293     (dump_func)dump_open_key_reply,
4294     NULL,
4295     NULL,
4296     (dump_func)dump_enum_key_reply,
4297     NULL,
4298     (dump_func)dump_get_key_value_reply,
4299     (dump_func)dump_enum_key_value_reply,
4300     NULL,
4301     NULL,
4302     NULL,
4303     NULL,
4304     NULL,
4305     (dump_func)dump_create_timer_reply,
4306     (dump_func)dump_open_timer_reply,
4307     (dump_func)dump_set_timer_reply,
4308     (dump_func)dump_cancel_timer_reply,
4309     (dump_func)dump_get_timer_info_reply,
4310     (dump_func)dump_get_thread_context_reply,
4311     (dump_func)dump_set_thread_context_reply,
4312     (dump_func)dump_get_selector_entry_reply,
4313     (dump_func)dump_add_atom_reply,
4314     NULL,
4315     (dump_func)dump_find_atom_reply,
4316     (dump_func)dump_get_atom_information_reply,
4317     NULL,
4318     NULL,
4319     (dump_func)dump_init_atom_table_reply,
4320     (dump_func)dump_get_msg_queue_reply,
4321     NULL,
4322     (dump_func)dump_set_queue_mask_reply,
4323     (dump_func)dump_get_queue_status_reply,
4324     (dump_func)dump_get_process_idle_event_reply,
4325     NULL,
4326     NULL,
4327     NULL,
4328     (dump_func)dump_get_message_reply,
4329     NULL,
4330     NULL,
4331     (dump_func)dump_get_message_reply_reply,
4332     (dump_func)dump_set_win_timer_reply,
4333     NULL,
4334     (dump_func)dump_is_window_hung_reply,
4335     (dump_func)dump_get_serial_info_reply,
4336     NULL,
4337     NULL,
4338     NULL,
4339     (dump_func)dump_ioctl_reply,
4340     (dump_func)dump_get_ioctl_result_reply,
4341     (dump_func)dump_create_named_pipe_reply,
4342     (dump_func)dump_get_named_pipe_info_reply,
4343     (dump_func)dump_create_window_reply,
4344     NULL,
4345     (dump_func)dump_get_desktop_window_reply,
4346     (dump_func)dump_set_window_owner_reply,
4347     (dump_func)dump_get_window_info_reply,
4348     (dump_func)dump_set_window_info_reply,
4349     (dump_func)dump_set_parent_reply,
4350     (dump_func)dump_get_window_parents_reply,
4351     (dump_func)dump_get_window_children_reply,
4352     (dump_func)dump_get_window_children_from_point_reply,
4353     (dump_func)dump_get_window_tree_reply,
4354     (dump_func)dump_set_window_pos_reply,
4355     (dump_func)dump_get_window_rectangles_reply,
4356     (dump_func)dump_get_window_text_reply,
4357     NULL,
4358     (dump_func)dump_get_windows_offset_reply,
4359     (dump_func)dump_get_visible_region_reply,
4360     (dump_func)dump_get_window_region_reply,
4361     NULL,
4362     (dump_func)dump_get_update_region_reply,
4363     NULL,
4364     NULL,
4365     NULL,
4366     (dump_func)dump_remove_window_property_reply,
4367     (dump_func)dump_get_window_property_reply,
4368     (dump_func)dump_get_window_properties_reply,
4369     (dump_func)dump_create_winstation_reply,
4370     (dump_func)dump_open_winstation_reply,
4371     NULL,
4372     (dump_func)dump_get_process_winstation_reply,
4373     NULL,
4374     (dump_func)dump_enum_winstation_reply,
4375     (dump_func)dump_create_desktop_reply,
4376     (dump_func)dump_open_desktop_reply,
4377     NULL,
4378     (dump_func)dump_get_thread_desktop_reply,
4379     NULL,
4380     (dump_func)dump_enum_desktop_reply,
4381     (dump_func)dump_set_user_object_info_reply,
4382     NULL,
4383     (dump_func)dump_get_thread_input_reply,
4384     (dump_func)dump_get_last_input_time_reply,
4385     (dump_func)dump_get_key_state_reply,
4386     NULL,
4387     (dump_func)dump_set_foreground_window_reply,
4388     (dump_func)dump_set_focus_window_reply,
4389     (dump_func)dump_set_active_window_reply,
4390     (dump_func)dump_set_capture_window_reply,
4391     (dump_func)dump_set_caret_window_reply,
4392     (dump_func)dump_set_caret_info_reply,
4393     (dump_func)dump_set_hook_reply,
4394     (dump_func)dump_remove_hook_reply,
4395     (dump_func)dump_start_hook_chain_reply,
4396     NULL,
4397     (dump_func)dump_get_hook_info_reply,
4398     (dump_func)dump_create_class_reply,
4399     (dump_func)dump_destroy_class_reply,
4400     (dump_func)dump_set_class_info_reply,
4401     (dump_func)dump_set_clipboard_info_reply,
4402     (dump_func)dump_open_token_reply,
4403     (dump_func)dump_set_global_windows_reply,
4404     (dump_func)dump_adjust_token_privileges_reply,
4405     (dump_func)dump_get_token_privileges_reply,
4406     (dump_func)dump_check_token_privileges_reply,
4407     (dump_func)dump_duplicate_token_reply,
4408     (dump_func)dump_access_check_reply,
4409     (dump_func)dump_get_token_user_reply,
4410     (dump_func)dump_get_token_groups_reply,
4411     NULL,
4412     (dump_func)dump_get_security_object_reply,
4413     (dump_func)dump_create_mailslot_reply,
4414     (dump_func)dump_set_mailslot_info_reply,
4415     (dump_func)dump_create_directory_reply,
4416     (dump_func)dump_open_directory_reply,
4417     (dump_func)dump_get_directory_entry_reply,
4418     (dump_func)dump_create_symlink_reply,
4419     (dump_func)dump_open_symlink_reply,
4420     (dump_func)dump_query_symlink_reply,
4421     (dump_func)dump_get_object_info_reply,
4422     NULL,
4423     (dump_func)dump_get_token_impersonation_level_reply,
4424     (dump_func)dump_allocate_locally_unique_id_reply,
4425     (dump_func)dump_create_device_manager_reply,
4426     (dump_func)dump_create_device_reply,
4427     NULL,
4428     (dump_func)dump_get_next_device_request_reply,
4429     (dump_func)dump_make_process_system_reply,
4430     (dump_func)dump_get_token_statistics_reply,
4431     (dump_func)dump_create_completion_reply,
4432     (dump_func)dump_open_completion_reply,
4433     NULL,
4434     (dump_func)dump_remove_completion_reply,
4435     (dump_func)dump_query_completion_reply,
4436     NULL,
4437     NULL,
4438     (dump_func)dump_get_window_layered_info_reply,
4439     NULL,
4440 };
4441
4442 static const char * const req_names[REQ_NB_REQUESTS] = {
4443     "new_process",
4444     "get_new_process_info",
4445     "new_thread",
4446     "get_startup_info",
4447     "init_process_done",
4448     "init_thread",
4449     "terminate_process",
4450     "terminate_thread",
4451     "get_process_info",
4452     "set_process_info",
4453     "get_thread_info",
4454     "set_thread_info",
4455     "get_dll_info",
4456     "suspend_thread",
4457     "resume_thread",
4458     "load_dll",
4459     "unload_dll",
4460     "queue_apc",
4461     "get_apc_result",
4462     "close_handle",
4463     "set_handle_info",
4464     "dup_handle",
4465     "open_process",
4466     "open_thread",
4467     "select",
4468     "create_event",
4469     "event_op",
4470     "open_event",
4471     "create_mutex",
4472     "release_mutex",
4473     "open_mutex",
4474     "create_semaphore",
4475     "release_semaphore",
4476     "open_semaphore",
4477     "create_file",
4478     "open_file_object",
4479     "alloc_file_handle",
4480     "get_handle_fd",
4481     "flush_file",
4482     "lock_file",
4483     "unlock_file",
4484     "create_socket",
4485     "accept_socket",
4486     "set_socket_event",
4487     "get_socket_event",
4488     "enable_socket_event",
4489     "set_socket_deferred",
4490     "alloc_console",
4491     "free_console",
4492     "get_console_renderer_events",
4493     "open_console",
4494     "get_console_wait_event",
4495     "get_console_mode",
4496     "set_console_mode",
4497     "set_console_input_info",
4498     "get_console_input_info",
4499     "append_console_input_history",
4500     "get_console_input_history",
4501     "create_console_output",
4502     "set_console_output_info",
4503     "get_console_output_info",
4504     "write_console_input",
4505     "read_console_input",
4506     "write_console_output",
4507     "fill_console_output",
4508     "read_console_output",
4509     "move_console_output",
4510     "send_console_signal",
4511     "read_directory_changes",
4512     "read_change",
4513     "create_mapping",
4514     "open_mapping",
4515     "get_mapping_info",
4516     "get_mapping_committed_range",
4517     "add_mapping_committed_range",
4518     "create_snapshot",
4519     "next_process",
4520     "next_thread",
4521     "wait_debug_event",
4522     "queue_exception_event",
4523     "get_exception_status",
4524     "output_debug_string",
4525     "continue_debug_event",
4526     "debug_process",
4527     "debug_break",
4528     "set_debugger_kill_on_exit",
4529     "read_process_memory",
4530     "write_process_memory",
4531     "create_key",
4532     "open_key",
4533     "delete_key",
4534     "flush_key",
4535     "enum_key",
4536     "set_key_value",
4537     "get_key_value",
4538     "enum_key_value",
4539     "delete_key_value",
4540     "load_registry",
4541     "unload_registry",
4542     "save_registry",
4543     "set_registry_notification",
4544     "create_timer",
4545     "open_timer",
4546     "set_timer",
4547     "cancel_timer",
4548     "get_timer_info",
4549     "get_thread_context",
4550     "set_thread_context",
4551     "get_selector_entry",
4552     "add_atom",
4553     "delete_atom",
4554     "find_atom",
4555     "get_atom_information",
4556     "set_atom_information",
4557     "empty_atom_table",
4558     "init_atom_table",
4559     "get_msg_queue",
4560     "set_queue_fd",
4561     "set_queue_mask",
4562     "get_queue_status",
4563     "get_process_idle_event",
4564     "send_message",
4565     "post_quit_message",
4566     "send_hardware_message",
4567     "get_message",
4568     "reply_message",
4569     "accept_hardware_message",
4570     "get_message_reply",
4571     "set_win_timer",
4572     "kill_win_timer",
4573     "is_window_hung",
4574     "get_serial_info",
4575     "set_serial_info",
4576     "register_async",
4577     "cancel_async",
4578     "ioctl",
4579     "get_ioctl_result",
4580     "create_named_pipe",
4581     "get_named_pipe_info",
4582     "create_window",
4583     "destroy_window",
4584     "get_desktop_window",
4585     "set_window_owner",
4586     "get_window_info",
4587     "set_window_info",
4588     "set_parent",
4589     "get_window_parents",
4590     "get_window_children",
4591     "get_window_children_from_point",
4592     "get_window_tree",
4593     "set_window_pos",
4594     "get_window_rectangles",
4595     "get_window_text",
4596     "set_window_text",
4597     "get_windows_offset",
4598     "get_visible_region",
4599     "get_window_region",
4600     "set_window_region",
4601     "get_update_region",
4602     "update_window_zorder",
4603     "redraw_window",
4604     "set_window_property",
4605     "remove_window_property",
4606     "get_window_property",
4607     "get_window_properties",
4608     "create_winstation",
4609     "open_winstation",
4610     "close_winstation",
4611     "get_process_winstation",
4612     "set_process_winstation",
4613     "enum_winstation",
4614     "create_desktop",
4615     "open_desktop",
4616     "close_desktop",
4617     "get_thread_desktop",
4618     "set_thread_desktop",
4619     "enum_desktop",
4620     "set_user_object_info",
4621     "attach_thread_input",
4622     "get_thread_input",
4623     "get_last_input_time",
4624     "get_key_state",
4625     "set_key_state",
4626     "set_foreground_window",
4627     "set_focus_window",
4628     "set_active_window",
4629     "set_capture_window",
4630     "set_caret_window",
4631     "set_caret_info",
4632     "set_hook",
4633     "remove_hook",
4634     "start_hook_chain",
4635     "finish_hook_chain",
4636     "get_hook_info",
4637     "create_class",
4638     "destroy_class",
4639     "set_class_info",
4640     "set_clipboard_info",
4641     "open_token",
4642     "set_global_windows",
4643     "adjust_token_privileges",
4644     "get_token_privileges",
4645     "check_token_privileges",
4646     "duplicate_token",
4647     "access_check",
4648     "get_token_user",
4649     "get_token_groups",
4650     "set_security_object",
4651     "get_security_object",
4652     "create_mailslot",
4653     "set_mailslot_info",
4654     "create_directory",
4655     "open_directory",
4656     "get_directory_entry",
4657     "create_symlink",
4658     "open_symlink",
4659     "query_symlink",
4660     "get_object_info",
4661     "unlink_object",
4662     "get_token_impersonation_level",
4663     "allocate_locally_unique_id",
4664     "create_device_manager",
4665     "create_device",
4666     "delete_device",
4667     "get_next_device_request",
4668     "make_process_system",
4669     "get_token_statistics",
4670     "create_completion",
4671     "open_completion",
4672     "add_completion",
4673     "remove_completion",
4674     "query_completion",
4675     "set_completion_info",
4676     "add_fd_completion",
4677     "get_window_layered_info",
4678     "set_window_layered_info",
4679 };
4680
4681 static const struct
4682 {
4683     const char  *name;
4684     unsigned int value;
4685 } status_names[] =
4686 {
4687     { "ABANDONED_WAIT_0",            STATUS_ABANDONED_WAIT_0 },
4688     { "ACCESS_DENIED",               STATUS_ACCESS_DENIED },
4689     { "ACCESS_VIOLATION",            STATUS_ACCESS_VIOLATION },
4690     { "ALERTED",                     STATUS_ALERTED },
4691     { "ALIAS_EXISTS",                STATUS_ALIAS_EXISTS },
4692     { "BAD_DEVICE_TYPE",             STATUS_BAD_DEVICE_TYPE },
4693     { "BAD_IMPERSONATION_LEVEL",     STATUS_BAD_IMPERSONATION_LEVEL },
4694     { "BREAKPOINT",                  STATUS_BREAKPOINT },
4695     { "BUFFER_OVERFLOW",             STATUS_BUFFER_OVERFLOW },
4696     { "BUFFER_TOO_SMALL",            STATUS_BUFFER_TOO_SMALL },
4697     { "CANCELLED",                   STATUS_CANCELLED },
4698     { "CANT_OPEN_ANONYMOUS",         STATUS_CANT_OPEN_ANONYMOUS },
4699     { "CHILD_MUST_BE_VOLATILE",      STATUS_CHILD_MUST_BE_VOLATILE },
4700     { "DEBUGGER_INACTIVE",           STATUS_DEBUGGER_INACTIVE },
4701     { "DEVICE_BUSY",                 STATUS_DEVICE_BUSY },
4702     { "DIRECTORY_NOT_EMPTY",         STATUS_DIRECTORY_NOT_EMPTY },
4703     { "DISK_FULL",                   STATUS_DISK_FULL },
4704     { "DLL_NOT_FOUND",               STATUS_DLL_NOT_FOUND },
4705     { "ERROR_CLASS_ALREADY_EXISTS",  0xc0010000 | ERROR_CLASS_ALREADY_EXISTS },
4706     { "ERROR_CLASS_DOES_NOT_EXIST",  0xc0010000 | ERROR_CLASS_DOES_NOT_EXIST },
4707     { "ERROR_CLASS_HAS_WINDOWS",     0xc0010000 | ERROR_CLASS_HAS_WINDOWS },
4708     { "ERROR_CLIPBOARD_NOT_OPEN",    0xc0010000 | ERROR_CLIPBOARD_NOT_OPEN },
4709     { "ERROR_INVALID_INDEX",         0xc0010000 | ERROR_INVALID_INDEX },
4710     { "ERROR_INVALID_WINDOW_HANDLE", 0xc0010000 | ERROR_INVALID_WINDOW_HANDLE },
4711     { "FILE_DELETED",                STATUS_FILE_DELETED },
4712     { "FILE_IS_A_DIRECTORY",         STATUS_FILE_IS_A_DIRECTORY },
4713     { "FILE_LOCK_CONFLICT",          STATUS_FILE_LOCK_CONFLICT },
4714     { "GENERIC_NOT_MAPPED",          STATUS_GENERIC_NOT_MAPPED },
4715     { "HANDLES_CLOSED",              STATUS_HANDLES_CLOSED },
4716     { "HANDLE_NOT_CLOSABLE",         STATUS_HANDLE_NOT_CLOSABLE },
4717     { "ILLEGAL_FUNCTION",            STATUS_ILLEGAL_FUNCTION },
4718     { "INSTANCE_NOT_AVAILABLE",      STATUS_INSTANCE_NOT_AVAILABLE },
4719     { "INSUFFICIENT_RESOURCES",      STATUS_INSUFFICIENT_RESOURCES },
4720     { "INVALID_CID",                 STATUS_INVALID_CID },
4721     { "INVALID_DEVICE_REQUEST",      STATUS_INVALID_DEVICE_REQUEST },
4722     { "INVALID_FILE_FOR_SECTION",    STATUS_INVALID_FILE_FOR_SECTION },
4723     { "INVALID_HANDLE",              STATUS_INVALID_HANDLE },
4724     { "INVALID_PARAMETER",           STATUS_INVALID_PARAMETER },
4725     { "INVALID_SECURITY_DESCR",      STATUS_INVALID_SECURITY_DESCR },
4726     { "IO_TIMEOUT",                  STATUS_IO_TIMEOUT },
4727     { "KEY_DELETED",                 STATUS_KEY_DELETED },
4728     { "MAPPED_FILE_SIZE_ZERO",       STATUS_MAPPED_FILE_SIZE_ZERO },
4729     { "MEDIA_WRITE_PROTECTED",       STATUS_MEDIA_WRITE_PROTECTED },
4730     { "MUTANT_NOT_OWNED",            STATUS_MUTANT_NOT_OWNED },
4731     { "NAME_TOO_LONG",               STATUS_NAME_TOO_LONG },
4732     { "NOTIFY_ENUM_DIR",             STATUS_NOTIFY_ENUM_DIR },
4733     { "NOT_ALL_ASSIGNED",            STATUS_NOT_ALL_ASSIGNED },
4734     { "NOT_A_DIRECTORY",             STATUS_NOT_A_DIRECTORY },
4735     { "NOT_IMPLEMENTED",             STATUS_NOT_IMPLEMENTED },
4736     { "NOT_REGISTRY_FILE",           STATUS_NOT_REGISTRY_FILE },
4737     { "NOT_SUPPORTED",               STATUS_NOT_SUPPORTED },
4738     { "NO_DATA_DETECTED",            STATUS_NO_DATA_DETECTED },
4739     { "NO_IMPERSONATION_TOKEN",      STATUS_NO_IMPERSONATION_TOKEN },
4740     { "NO_MEMORY",                   STATUS_NO_MEMORY },
4741     { "NO_MORE_ENTRIES",             STATUS_NO_MORE_ENTRIES },
4742     { "NO_MORE_FILES",               STATUS_NO_MORE_FILES },
4743     { "NO_SUCH_DEVICE",              STATUS_NO_SUCH_DEVICE },
4744     { "NO_SUCH_FILE",                STATUS_NO_SUCH_FILE },
4745     { "NO_TOKEN",                    STATUS_NO_TOKEN },
4746     { "OBJECT_NAME_COLLISION",       STATUS_OBJECT_NAME_COLLISION },
4747     { "OBJECT_NAME_EXISTS",          STATUS_OBJECT_NAME_EXISTS },
4748     { "OBJECT_NAME_INVALID",         STATUS_OBJECT_NAME_INVALID },
4749     { "OBJECT_NAME_NOT_FOUND",       STATUS_OBJECT_NAME_NOT_FOUND },
4750     { "OBJECT_PATH_INVALID",         STATUS_OBJECT_PATH_INVALID },
4751     { "OBJECT_PATH_NOT_FOUND",       STATUS_OBJECT_PATH_NOT_FOUND },
4752     { "OBJECT_PATH_SYNTAX_BAD",      STATUS_OBJECT_PATH_SYNTAX_BAD },
4753     { "OBJECT_TYPE_MISMATCH",        STATUS_OBJECT_TYPE_MISMATCH },
4754     { "PENDING",                     STATUS_PENDING },
4755     { "PIPE_BUSY",                   STATUS_PIPE_BUSY },
4756     { "PIPE_CONNECTED",              STATUS_PIPE_CONNECTED },
4757     { "PIPE_DISCONNECTED",           STATUS_PIPE_DISCONNECTED },
4758     { "PIPE_LISTENING",              STATUS_PIPE_LISTENING },
4759     { "PIPE_NOT_AVAILABLE",          STATUS_PIPE_NOT_AVAILABLE },
4760     { "PRIVILEGE_NOT_HELD",          STATUS_PRIVILEGE_NOT_HELD },
4761     { "PROCESS_IS_TERMINATING",      STATUS_PROCESS_IS_TERMINATING },
4762     { "SECTION_TOO_BIG",             STATUS_SECTION_TOO_BIG },
4763     { "SEMAPHORE_LIMIT_EXCEEDED",    STATUS_SEMAPHORE_LIMIT_EXCEEDED },
4764     { "SHARING_VIOLATION",           STATUS_SHARING_VIOLATION },
4765     { "SHUTDOWN_IN_PROGRESS",        STATUS_SHUTDOWN_IN_PROGRESS },
4766     { "SUSPEND_COUNT_EXCEEDED",      STATUS_SUSPEND_COUNT_EXCEEDED },
4767     { "THREAD_IS_TERMINATING",       STATUS_THREAD_IS_TERMINATING },
4768     { "TIMEOUT",                     STATUS_TIMEOUT },
4769     { "TOO_MANY_OPENED_FILES",       STATUS_TOO_MANY_OPENED_FILES },
4770     { "UNSUCCESSFUL",                STATUS_UNSUCCESSFUL },
4771     { "USER_APC",                    STATUS_USER_APC },
4772     { "VOLUME_DISMOUNTED",           STATUS_VOLUME_DISMOUNTED },
4773     { "WAS_LOCKED",                  STATUS_WAS_LOCKED },
4774     { NULL, 0 }
4775 };
4776
4777 /* ### make_requests end ### */
4778 /* Everything above this line is generated automatically by tools/make_requests */
4779
4780 static const char *get_status_name( unsigned int status )
4781 {
4782     int i;
4783     static char buffer[10];
4784
4785     if (status)
4786     {
4787         for (i = 0; status_names[i].name; i++)
4788             if (status_names[i].value == status) return status_names[i].name;
4789     }
4790     sprintf( buffer, "%x", status );
4791     return buffer;
4792 }
4793
4794 void trace_request(void)
4795 {
4796     enum request req = current->req.request_header.req;
4797     if (req < REQ_NB_REQUESTS)
4798     {
4799         fprintf( stderr, "%04x: %s(", current->id, req_names[req] );
4800         if (req_dumpers[req])
4801         {
4802             cur_data = get_req_data();
4803             cur_size = get_req_data_size();
4804             req_dumpers[req]( &current->req );
4805         }
4806         fprintf( stderr, " )\n" );
4807     }
4808     else fprintf( stderr, "%04x: %d(?)\n", current->id, req );
4809 }
4810
4811 void trace_reply( enum request req, const union generic_reply *reply )
4812 {
4813     if (req < REQ_NB_REQUESTS)
4814     {
4815         fprintf( stderr, "%04x: %s() = %s",
4816                  current->id, req_names[req], get_status_name(current->error) );
4817         if (reply_dumpers[req])
4818         {
4819             fprintf( stderr, " {" );
4820             cur_data = current->reply_data;
4821             cur_size = reply->reply_header.reply_size;
4822             reply_dumpers[req]( reply );
4823             fprintf( stderr, " }" );
4824         }
4825         fputc( '\n', stderr );
4826     }
4827     else fprintf( stderr, "%04x: %d() = %s\n",
4828                   current->id, req, get_status_name(current->error) );
4829 }