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