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

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