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