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