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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 "windef.h"
  34 #include "winbase.h"
  35 #include "wincon.h"
  36 #include "winreg.h"
  37 #include "winternl.h"
  38 #include "request.h"
  39 #include "unicode.h"
  40
  41 static int cur_pos;
  42 static const void *cur_data;
  43 static int cur_size;
  44
  45 /* utility functions */
  46
  47 inline static void remove_data( size_t size )
  48 {
  49     cur_data = (const char *)cur_data + size;
  50     cur_size -= size;
  51 }
  52
  53 static void dump_uints( const int *ptr, int len )
  54 {
  55     fputc( '{', stderr );
  56     while (len > 0)
  57     {
  58         fprintf( stderr, "%08x", *ptr++ );
  59         if (--len) fputc( ',', stderr );
  60     }
  61     fputc( '}', stderr );
  62 }
  63
  64 static void dump_abs_time( const abs_time_t *time )
  65 {
  66     struct timeval tv;
  67     int secs, usecs;
  68
  69     if (!time->sec && !time->usec)
  70     {
  71         fprintf( stderr, "0" );
  72         return;
  73     }
  74     gettimeofday( &tv, NULL );
  75     secs = time->sec - tv.tv_sec;
  76     if ((usecs = time->usec - tv.tv_usec) < 0)
  77     {
  78         usecs += 1000000;
  79         secs--;
  80     }
  81     if (secs > 0 || (secs == 0 && usecs >= 0))
  82         fprintf( stderr, "%d.%06d (+%d.%06d)", time->sec, time->usec, secs, usecs );
  83     else
  84         fprintf( stderr, "%d.%06d (-%d.%06d)", time->sec, time->usec, abs(secs+1), 1000000-usecs );
  85 }
  86
  87 static void dump_rectangle( const rectangle_t *rect )
  88 {
  89     fprintf( stderr, "{%d,%d;%d,%d}",
  90              rect->left, rect->top, rect->right, rect->bottom );
  91 }
  92
  93 static void dump_char_info( const char_info_t *info )
  94 {
  95     fprintf( stderr, "{'" );
  96     dump_strW( &info->ch, 1, stderr, "\'\'" );
  97     fprintf( stderr, "',%04x}", info->attr );
  98 }
  99
 100 static void dump_context( const CONTEXT *context )
 101 {
 102 #ifdef __i386__
 103     fprintf( stderr, "{flags=%08lx,eax=%08lx,ebx=%08lx,ecx=%08lx,edx=%08lx,esi=%08lx,edi=%08lx,"
 104              "ebp=%08lx,eip=%08lx,esp=%08lx,eflags=%08lx,cs=%04lx,ds=%04lx,es=%04lx,"
 105              "fs=%04lx,gs=%04lx,dr0=%08lx,dr1=%08lx,dr2=%08lx,dr3=%08lx,dr6=%08lx,dr7=%08lx,",
 106              context->ContextFlags, context->Eax, context->Ebx, context->Ecx, context->Edx,
 107              context->Esi, context->Edi, context->Ebp, context->Eip, context->Esp, context->EFlags,
 108              context->SegCs, context->SegDs, context->SegEs, context->SegFs, context->SegGs,
 109              context->Dr0, context->Dr1, context->Dr2, context->Dr3, context->Dr6, context->Dr7 );
 110     fprintf( stderr, "float=" );
 111     dump_uints( (const int *)&context->FloatSave, sizeof(context->FloatSave) / sizeof(int) );
 112     fprintf( stderr, "}" );
 113 #else
 114     dump_uints( (const int *)context, sizeof(*context) / sizeof(int) );
 115 #endif
 116 }
 117
 118 static void dump_exc_record( const EXCEPTION_RECORD *rec )
 119 {
 120     unsigned int i;
 121     fprintf( stderr, "{code=%lx,flags=%lx,rec=%p,addr=%p,params={",
 122              rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionRecord,
 123              rec->ExceptionAddress );
 124     for (i = 0; i < min(rec->NumberParameters,EXCEPTION_MAXIMUM_PARAMETERS); i++)
 125     {
 126         if (i) fputc( ',', stderr );
 127         fprintf( stderr, "%lx", rec->ExceptionInformation[i] );
 128     }
 129     fputc( '}', stderr );
 130 }
 131
 132 static void dump_varargs_ints( size_t size )
 133 {
 134     const int *data = cur_data;
 135     size_t len = size / sizeof(*data);
 136
 137     fputc( '{', stderr );
 138     while (len > 0)
 139     {
 140         fprintf( stderr, "%d", *data++ );
 141         if (--len) fputc( ',', stderr );
 142     }
 143     fputc( '}', stderr );
 144     remove_data( size );
 145 }
 146
 147 static void dump_varargs_handles( size_t size )
 148 {
 149     const obj_handle_t *data = cur_data;
 150     size_t len = size / sizeof(*data);
 151
 152     fputc( '{', stderr );
 153     while (len > 0)
 154     {
 155         fprintf( stderr, "%p", *data++ );
 156         if (--len) fputc( ',', stderr );
 157     }
 158     fputc( '}', stderr );
 159     remove_data( size );
 160 }
 161
 162 static void dump_varargs_user_handles( size_t size )
 163 {
 164     const user_handle_t *data = cur_data;
 165     size_t len = size / sizeof(*data);
 166
 167     fputc( '{', stderr );
 168     while (len > 0)
 169     {
 170         fprintf( stderr, "%p", *data++ );
 171         if (--len) fputc( ',', stderr );
 172     }
 173     fputc( '}', stderr );
 174     remove_data( size );
 175 }
 176
 177 static void dump_varargs_bytes( size_t size )
 178 {
 179     const unsigned char *data = cur_data;
 180     size_t len = size;
 181
 182     fputc( '{', stderr );
 183     while (len > 0)
 184     {
 185         fprintf( stderr, "%02x", *data++ );
 186         if (--len) fputc( ',', stderr );
 187     }
 188     fputc( '}', stderr );
 189     remove_data( size );
 190 }
 191
 192 static void dump_varargs_string( size_t size )
 193 {
 194     fprintf( stderr, "\"%.*s\"", (int)size, (const char *)cur_data );
 195     remove_data( size );
 196 }
 197
 198 static void dump_varargs_unicode_str( size_t size )
 199 {
 200     fprintf( stderr, "L\"" );
 201     dump_strW( cur_data, size / sizeof(WCHAR), stderr, "\"\"" );
 202     fputc( '\"', stderr );
 203     remove_data( size );
 204 }
 205
 206 static void dump_varargs_context( size_t size )
 207 {
 208     if (!size)
 209     {
 210         fprintf( stderr, "{}" );
 211         return;
 212     }
 213     dump_context( cur_data );
 214     remove_data( size );
 215 }
 216
 217 static void dump_varargs_exc_event( size_t size )
 218 {
 219     const CONTEXT *ptr = cur_data;
 220
 221     if (!size)
 222     {
 223         fprintf( stderr, "{}" );
 224         return;
 225     }
 226     fprintf( stderr, "{context=" );
 227     dump_context( ptr );
 228     fprintf( stderr, ",rec=" );
 229     dump_exc_record( (const EXCEPTION_RECORD *)(ptr + 1) );
 230     fputc( '}', stderr );
 231     remove_data( size );
 232 }
 233
 234 static void dump_varargs_debug_event( size_t size )
 235 {
 236     const debug_event_t *event = cur_data;
 237
 238     if (!size)
 239     {
 240         fprintf( stderr, "{}" );
 241         return;
 242     }
 243     switch(event->code)
 244     {
 245     case EXCEPTION_DEBUG_EVENT:
 246         fprintf( stderr, "{exception," );
 247         dump_exc_record( &event->info.exception.record );
 248         fprintf( stderr, ",first=%d}", event->info.exception.first );
 249         break;
 250     case CREATE_THREAD_DEBUG_EVENT:
 251         fprintf( stderr, "{create_thread,thread=%p,teb=%p,start=%p}",
 252                  event->info.create_thread.handle, event->info.create_thread.teb,
 253                  event->info.create_thread.start );
 254         break;
 255     case CREATE_PROCESS_DEBUG_EVENT:
 256         fprintf( stderr, "{create_process,file=%p,process=%p,thread=%p,base=%p,offset=%d,"
 257                          "size=%d,teb=%p,start=%p,name=%p,unicode=%d}",
 258                  event->info.create_process.file, event->info.create_process.process,
 259                  event->info.create_process.thread, event->info.create_process.base,
 260                  event->info.create_process.dbg_offset, event->info.create_process.dbg_size,
 261                  event->info.create_process.teb, event->info.create_process.start,
 262                  event->info.create_process.name, event->info.create_process.unicode );
 263         break;
 264     case EXIT_THREAD_DEBUG_EVENT:
 265         fprintf( stderr, "{exit_thread,code=%d}", event->info.exit.exit_code );
 266         break;
 267     case EXIT_PROCESS_DEBUG_EVENT:
 268         fprintf( stderr, "{exit_process,code=%d}", event->info.exit.exit_code );
 269         break;
 270     case LOAD_DLL_DEBUG_EVENT:
 271         fprintf( stderr, "{load_dll,file=%p,base=%p,offset=%d,size=%d,name=%p,unicode=%d}",
 272                  event->info.load_dll.handle, event->info.load_dll.base,
 273                  event->info.load_dll.dbg_offset, event->info.load_dll.dbg_size,
 274                  event->info.load_dll.name, event->info.load_dll.unicode );
 275         break;
 276     case UNLOAD_DLL_DEBUG_EVENT:
 277         fprintf( stderr, "{unload_dll,base=%p}", event->info.unload_dll.base );
 278         break;
 279     case OUTPUT_DEBUG_STRING_EVENT:
 280         fprintf( stderr, "{output_string,data=%p,unicode=%d,len=%d}",
 281                  event->info.output_string.string, event->info.output_string.unicode,
 282                  event->info.output_string.length );
 283         break;
 284     case RIP_EVENT:
 285         fprintf( stderr, "{rip,err=%d,type=%d}",
 286                  event->info.rip_info.error, event->info.rip_info.type );
 287         break;
 288     case 0:  /* zero is the code returned on timeouts */
 289         fprintf( stderr, "{}" );
 290         break;
 291     default:
 292         fprintf( stderr, "{code=??? (%d)}", event->code );
 293         break;
 294     }
 295     remove_data( size );
 296 }
 297
 298 /* dump a unicode string contained in a buffer; helper for dump_varargs_startup_info */
 299 static void dump_inline_unicode_string( const UNICODE_STRING *str, const void *data, size_t size )
 300 {
 301     size_t length = str->Length / sizeof(WCHAR);
 302     size_t offset = (size_t)str->Buffer;
 303
 304     if (offset >= size) return;
 305     if (offset + length > size) length = size - offset;
 306     dump_strW( (const WCHAR *)data + offset/sizeof(WCHAR), length, stderr, "\"\"" );
 307 }
 308
 309 static void dump_varargs_startup_info( size_t size )
 310 {
 311     const RTL_USER_PROCESS_PARAMETERS *ptr = cur_data;
 312     RTL_USER_PROCESS_PARAMETERS params;
 313
 314     if (size < sizeof(params.Size))
 315     {
 316         fprintf( stderr, "{}" );
 317         return;
 318     }
 319     if (size > ptr->Size) size = ptr->Size;
 320     memset( &params, 0, sizeof(params) );
 321     memcpy( &params, ptr, min( size, sizeof(params) ));
 322
 323     fprintf( stderr, "{AllocationSize=%lx,", params.AllocationSize );
 324     fprintf( stderr, "Size=%lx,", params.Size );
 325     fprintf( stderr, "Flags=%lx,", params.Flags );
 326     fprintf( stderr, "DebugFlags=%lx,", params.DebugFlags );
 327     fprintf( stderr, "ConsoleHandle=%p,", params.ConsoleHandle );
 328     fprintf( stderr, "ConsoleFlags=%lx,", params.ConsoleFlags );
 329     fprintf( stderr, "hStdInput=%p,", params.hStdInput );
 330     fprintf( stderr, "hStdOutput=%p,", params.hStdOutput );
 331     fprintf( stderr, "hStdError=%p,", params.hStdError );
 332     fprintf( stderr, "CurrentDirectory.Handle=%p,", params.CurrentDirectory.Handle );
 333     fprintf( stderr, "dwX=%ld,", params.dwX );
 334     fprintf( stderr, "dwY=%ld,", params.dwY );
 335     fprintf( stderr, "dwXSize=%ld,", params.dwXSize );
 336     fprintf( stderr, "dwYSize=%ld,", params.dwYSize );
 337     fprintf( stderr, "dwXCountChars=%ld,", params.dwXCountChars );
 338     fprintf( stderr, "dwYCountChars=%ld,", params.dwYCountChars );
 339     fprintf( stderr, "dwFillAttribute=%lx,", params.dwFillAttribute );
 340     fprintf( stderr, "dwFlags=%lx,", params.dwFlags );
 341     fprintf( stderr, "wShowWindow=%lx,", params.wShowWindow );
 342     fprintf( stderr, "CurrentDirectory.DosPath=L\"" );
 343     dump_inline_unicode_string( &params.CurrentDirectory.DosPath, cur_data, size );
 344     fprintf( stderr, "\",DllPath=L\"" );
 345     dump_inline_unicode_string( &params.DllPath, cur_data, size );
 346     fprintf( stderr, "\",ImagePathName=L\"" );
 347     dump_inline_unicode_string( &params.ImagePathName, cur_data, size );
 348     fprintf( stderr, "\",CommandLine=L\"" );
 349     dump_inline_unicode_string( &params.CommandLine, cur_data, size );
 350     fprintf( stderr, "\",WindowTitle=L\"" );
 351     dump_inline_unicode_string( &params.WindowTitle, cur_data, size );
 352     fprintf( stderr, "\",Desktop=L\"" );
 353     dump_inline_unicode_string( &params.Desktop, cur_data, size );
 354     fprintf( stderr, "\",ShellInfo=L\"" );
 355     dump_inline_unicode_string( &params.ShellInfo, cur_data, size );
 356     fprintf( stderr, "\",RuntimeInfo=L\"" );
 357     dump_inline_unicode_string( &params.RuntimeInfo, cur_data, size );
 358     fprintf( stderr, "\"}" );
 359     remove_data( size );
 360 }
 361
 362 static void dump_varargs_input_records( size_t size )
 363 {
 364     const INPUT_RECORD *rec = cur_data;
 365     size_t len = size / sizeof(*rec);
 366
 367     fputc( '{', stderr );
 368     while (len > 0)
 369     {
 370         fprintf( stderr, "{%04x,...}", rec->EventType );
 371         rec++;
 372         if (--len) fputc( ',', stderr );
 373     }
 374     fputc( '}', stderr );
 375     remove_data( size );
 376 }
 377
 378 static void dump_varargs_rectangles( size_t size )
 379 {
 380     const rectangle_t *rect = cur_data;
 381     size_t len = size / sizeof(*rect);
 382
 383     fputc( '{', stderr );
 384     while (len > 0)
 385     {
 386         dump_rectangle( rect++ );
 387         if (--len) fputc( ',', stderr );
 388     }
 389     fputc( '}', stderr );
 390     remove_data( size );
 391 }
 392
 393 static void dump_varargs_properties( size_t size )
 394 {
 395     const property_data_t *prop = cur_data;
 396     size_t len = size / sizeof(*prop);
 397
 398     fputc( '{', stderr );
 399     while (len > 0)
 400     {
 401         fprintf( stderr, "{atom=%04x,str=%d,handle=%p}",
 402                  prop->atom, prop->string, prop->handle );
 403         prop++;
 404         if (--len) fputc( ',', stderr );
 405     }
 406     fputc( '}', stderr );
 407     remove_data( size );
 408 }
 409
 410 static void dump_varargs_LUID_AND_ATTRIBUTES( size_t size )
 411 {
 412     const LUID_AND_ATTRIBUTES *lat = cur_data;
 413     size_t len = size / sizeof(*lat);
 414
 415     fputc( '{', stderr );
 416     while (len > 0)
 417     {
 418         fprintf( stderr, "{luid=%08lx%08lx,attr=%lx}",
 419                  lat->Luid.HighPart, lat->Luid.LowPart, lat->Attributes );
 420         lat++;
 421         if (--len) fputc( ',', stderr );
 422     }
 423     fputc( '}', stderr );
 424     remove_data( size );
 425 }
 426
 427 typedef void (*dump_func)( const void *req );
 428
 429 /* Everything below this line is generated automatically by tools/make_requests */
 430 /* ### make_requests begin ### */
 431
 432 static void dump_new_process_request( const struct new_process_request *req )
 433 {
 434     fprintf( stderr, " inherit_all=%d,", req->inherit_all );
 435     fprintf( stderr, " create_flags=%d,", req->create_flags );
 436     fprintf( stderr, " unix_pid=%d,", req->unix_pid );
 437     fprintf( stderr, " exe_file=%p,", req->exe_file );
 438     fprintf( stderr, " hstdin=%p,", req->hstdin );
 439     fprintf( stderr, " hstdout=%p,", req->hstdout );
 440     fprintf( stderr, " hstderr=%p,", req->hstderr );
 441     fprintf( stderr, " info=" );
 442     dump_varargs_startup_info( cur_size );
 443     fputc( ',', stderr );
 444     fprintf( stderr, " env=" );
 445     dump_varargs_unicode_str( cur_size );
 446 }
 447
 448 static void dump_new_process_reply( const struct new_process_reply *req )
 449 {
 450     fprintf( stderr, " info=%p", req->info );
 451 }
 452
 453 static void dump_get_new_process_info_request( const struct get_new_process_info_request *req )
 454 {
 455     fprintf( stderr, " info=%p,", req->info );
 456     fprintf( stderr, " pinherit=%d,", req->pinherit );
 457     fprintf( stderr, " tinherit=%d", req->tinherit );
 458 }
 459
 460 static void dump_get_new_process_info_reply( const struct get_new_process_info_reply *req )
 461 {
 462     fprintf( stderr, " pid=%04x,", req->pid );
 463     fprintf( stderr, " phandle=%p,", req->phandle );
 464     fprintf( stderr, " tid=%04x,", req->tid );
 465     fprintf( stderr, " thandle=%p,", req->thandle );
 466     fprintf( stderr, " success=%d", req->success );
 467 }
 468
 469 static void dump_new_thread_request( const struct new_thread_request *req )
 470 {
 471     fprintf( stderr, " suspend=%d,", req->suspend );
 472     fprintf( stderr, " inherit=%d,", req->inherit );
 473     fprintf( stderr, " request_fd=%d", req->request_fd );
 474 }
 475
 476 static void dump_new_thread_reply( const struct new_thread_reply *req )
 477 {
 478     fprintf( stderr, " tid=%04x,", req->tid );
 479     fprintf( stderr, " handle=%p", req->handle );
 480 }
 481
 482 static void dump_boot_done_request( const struct boot_done_request *req )
 483 {
 484     fprintf( stderr, " debug_level=%d", req->debug_level );
 485 }
 486
 487 static void dump_init_process_request( const struct init_process_request *req )
 488 {
 489     fprintf( stderr, " peb=%p,", req->peb );
 490     fprintf( stderr, " ldt_copy=%p", req->ldt_copy );
 491 }
 492
 493 static void dump_init_process_reply( const struct init_process_reply *req )
 494 {
 495     fprintf( stderr, " create_flags=%d,", req->create_flags );
 496     fprintf( stderr, " server_start=%08x,", req->server_start );
 497     fprintf( stderr, " info_size=%d,", req->info_size );
 498     fprintf( stderr, " exe_file=%p,", req->exe_file );
 499     fprintf( stderr, " hstdin=%p,", req->hstdin );
 500     fprintf( stderr, " hstdout=%p,", req->hstdout );
 501     fprintf( stderr, " hstderr=%p", req->hstderr );
 502 }
 503
 504 static void dump_get_startup_info_request( const struct get_startup_info_request *req )
 505 {
 506 }
 507
 508 static void dump_get_startup_info_reply( const struct get_startup_info_reply *req )
 509 {
 510     fprintf( stderr, " info=" );
 511     dump_varargs_startup_info( cur_size );
 512     fputc( ',', stderr );
 513     fprintf( stderr, " env=" );
 514     dump_varargs_unicode_str( cur_size );
 515 }
 516
 517 static void dump_init_process_done_request( const struct init_process_done_request *req )
 518 {
 519     fprintf( stderr, " module=%p,", req->module );
 520     fprintf( stderr, " module_size=%d,", req->module_size );
 521     fprintf( stderr, " entry=%p,", req->entry );
 522     fprintf( stderr, " name=%p,", req->name );
 523     fprintf( stderr, " exe_file=%p,", req->exe_file );
 524     fprintf( stderr, " gui=%d,", req->gui );
 525     fprintf( stderr, " filename=" );
 526     dump_varargs_unicode_str( cur_size );
 527 }
 528
 529 static void dump_init_thread_request( const struct init_thread_request *req )
 530 {
 531     fprintf( stderr, " unix_pid=%d,", req->unix_pid );
 532     fprintf( stderr, " unix_tid=%d,", req->unix_tid );
 533     fprintf( stderr, " teb=%p,", req->teb );
 534     fprintf( stderr, " entry=%p,", req->entry );
 535     fprintf( stderr, " reply_fd=%d,", req->reply_fd );
 536     fprintf( stderr, " wait_fd=%d", req->wait_fd );
 537 }
 538
 539 static void dump_init_thread_reply( const struct init_thread_reply *req )
 540 {
 541     fprintf( stderr, " pid=%04x,", req->pid );
 542     fprintf( stderr, " tid=%04x,", req->tid );
 543     fprintf( stderr, " boot=%d,", req->boot );
 544     fprintf( stderr, " version=%d", req->version );
 545 }
 546
 547 static void dump_terminate_process_request( const struct terminate_process_request *req )
 548 {
 549     fprintf( stderr, " handle=%p,", req->handle );
 550     fprintf( stderr, " exit_code=%d", req->exit_code );
 551 }
 552
 553 static void dump_terminate_process_reply( const struct terminate_process_reply *req )
 554 {
 555     fprintf( stderr, " self=%d", req->self );
 556 }
 557
 558 static void dump_terminate_thread_request( const struct terminate_thread_request *req )
 559 {
 560     fprintf( stderr, " handle=%p,", req->handle );
 561     fprintf( stderr, " exit_code=%d", req->exit_code );
 562 }
 563
 564 static void dump_terminate_thread_reply( const struct terminate_thread_reply *req )
 565 {
 566     fprintf( stderr, " self=%d,", req->self );
 567     fprintf( stderr, " last=%d", req->last );
 568 }
 569
 570 static void dump_get_process_info_request( const struct get_process_info_request *req )
 571 {
 572     fprintf( stderr, " handle=%p", req->handle );
 573 }
 574
 575 static void dump_get_process_info_reply( const struct get_process_info_reply *req )
 576 {
 577     fprintf( stderr, " pid=%04x,", req->pid );
 578     fprintf( stderr, " ppid=%04x,", req->ppid );
 579     fprintf( stderr, " exit_code=%d,", req->exit_code );
 580     fprintf( stderr, " priority=%d,", req->priority );
 581     fprintf( stderr, " process_affinity=%d,", req->process_affinity );
 582     fprintf( stderr, " system_affinity=%d,", req->system_affinity );
 583     fprintf( stderr, " peb=%p", req->peb );
 584 }
 585
 586 static void dump_set_process_info_request( const struct set_process_info_request *req )
 587 {
 588     fprintf( stderr, " handle=%p,", req->handle );
 589     fprintf( stderr, " mask=%d,", req->mask );
 590     fprintf( stderr, " priority=%d,", req->priority );
 591     fprintf( stderr, " affinity=%d", req->affinity );
 592 }
 593
 594 static void dump_get_thread_info_request( const struct get_thread_info_request *req )
 595 {
 596     fprintf( stderr, " handle=%p,", req->handle );
 597     fprintf( stderr, " tid_in=%04x", req->tid_in );
 598 }
 599
 600 static void dump_get_thread_info_reply( const struct get_thread_info_reply *req )
 601 {
 602     fprintf( stderr, " pid=%04x,", req->pid );
 603     fprintf( stderr, " tid=%04x,", req->tid );
 604     fprintf( stderr, " teb=%p,", req->teb );
 605     fprintf( stderr, " exit_code=%d,", req->exit_code );
 606     fprintf( stderr, " priority=%d,", req->priority );
 607     fprintf( stderr, " affinity=%d,", req->affinity );
 608     fprintf( stderr, " creation_time=%ld,", (long)req->creation_time );
 609     fprintf( stderr, " exit_time=%ld", (long)req->exit_time );
 610 }
 611
 612 static void dump_set_thread_info_request( const struct set_thread_info_request *req )
 613 {
 614     fprintf( stderr, " handle=%p,", req->handle );
 615     fprintf( stderr, " mask=%d,", req->mask );
 616     fprintf( stderr, " priority=%d,", req->priority );
 617     fprintf( stderr, " affinity=%d", req->affinity );
 618 }
 619
 620 static void dump_get_dll_info_request( const struct get_dll_info_request *req )
 621 {
 622     fprintf( stderr, " handle=%p,", req->handle );
 623     fprintf( stderr, " base_address=%p", req->base_address );
 624 }
 625
 626 static void dump_get_dll_info_reply( const struct get_dll_info_reply *req )
 627 {
 628     fprintf( stderr, " size=%d,", req->size );
 629     fprintf( stderr, " entry_point=%p,", req->entry_point );
 630     fprintf( stderr, " filename=" );
 631     dump_varargs_unicode_str( cur_size );
 632 }
 633
 634 static void dump_suspend_thread_request( const struct suspend_thread_request *req )
 635 {
 636     fprintf( stderr, " handle=%p", req->handle );
 637 }
 638
 639 static void dump_suspend_thread_reply( const struct suspend_thread_reply *req )
 640 {
 641     fprintf( stderr, " count=%d", req->count );
 642 }
 643
 644 static void dump_resume_thread_request( const struct resume_thread_request *req )
 645 {
 646     fprintf( stderr, " handle=%p", req->handle );
 647 }
 648
 649 static void dump_resume_thread_reply( const struct resume_thread_reply *req )
 650 {
 651     fprintf( stderr, " count=%d", req->count );
 652 }
 653
 654 static void dump_load_dll_request( const struct load_dll_request *req )
 655 {
 656     fprintf( stderr, " handle=%p,", req->handle );
 657     fprintf( stderr, " base=%p,", req->base );
 658     fprintf( stderr, " size=%d,", req->size );
 659     fprintf( stderr, " dbg_offset=%d,", req->dbg_offset );
 660     fprintf( stderr, " dbg_size=%d,", req->dbg_size );
 661     fprintf( stderr, " name=%p,", req->name );
 662     fprintf( stderr, " filename=" );
 663     dump_varargs_unicode_str( cur_size );
 664 }
 665
 666 static void dump_unload_dll_request( const struct unload_dll_request *req )
 667 {
 668     fprintf( stderr, " base=%p", req->base );
 669 }
 670
 671 static void dump_queue_apc_request( const struct queue_apc_request *req )
 672 {
 673     fprintf( stderr, " handle=%p,", req->handle );
 674     fprintf( stderr, " user=%d,", req->user );
 675     fprintf( stderr, " func=%p,", req->func );
 676     fprintf( stderr, " arg1=%p,", req->arg1 );
 677     fprintf( stderr, " arg2=%p,", req->arg2 );
 678     fprintf( stderr, " arg3=%p", req->arg3 );
 679 }
 680
 681 static void dump_get_apc_request( const struct get_apc_request *req )
 682 {
 683     fprintf( stderr, " alertable=%d", req->alertable );
 684 }
 685
 686 static void dump_get_apc_reply( const struct get_apc_reply *req )
 687 {
 688     fprintf( stderr, " func=%p,", req->func );
 689     fprintf( stderr, " type=%d,", req->type );
 690     fprintf( stderr, " arg1=%p,", req->arg1 );
 691     fprintf( stderr, " arg2=%p,", req->arg2 );
 692     fprintf( stderr, " arg3=%p", req->arg3 );
 693 }
 694
 695 static void dump_close_handle_request( const struct close_handle_request *req )
 696 {
 697     fprintf( stderr, " handle=%p", req->handle );
 698 }
 699
 700 static void dump_close_handle_reply( const struct close_handle_reply *req )
 701 {
 702     fprintf( stderr, " fd=%d", req->fd );
 703 }
 704
 705 static void dump_set_handle_info_request( const struct set_handle_info_request *req )
 706 {
 707     fprintf( stderr, " handle=%p,", req->handle );
 708     fprintf( stderr, " flags=%d,", req->flags );
 709     fprintf( stderr, " mask=%d,", req->mask );
 710     fprintf( stderr, " fd=%d", req->fd );
 711 }
 712
 713 static void dump_set_handle_info_reply( const struct set_handle_info_reply *req )
 714 {
 715     fprintf( stderr, " old_flags=%d,", req->old_flags );
 716     fprintf( stderr, " cur_fd=%d", req->cur_fd );
 717 }
 718
 719 static void dump_dup_handle_request( const struct dup_handle_request *req )
 720 {
 721     fprintf( stderr, " src_process=%p,", req->src_process );
 722     fprintf( stderr, " src_handle=%p,", req->src_handle );
 723     fprintf( stderr, " dst_process=%p,", req->dst_process );
 724     fprintf( stderr, " access=%08x,", req->access );
 725     fprintf( stderr, " inherit=%d,", req->inherit );
 726     fprintf( stderr, " options=%d", req->options );
 727 }
 728
 729 static void dump_dup_handle_reply( const struct dup_handle_reply *req )
 730 {
 731     fprintf( stderr, " handle=%p,", req->handle );
 732     fprintf( stderr, " fd=%d", req->fd );
 733 }
 734
 735 static void dump_open_process_request( const struct open_process_request *req )
 736 {
 737     fprintf( stderr, " pid=%04x,", req->pid );
 738     fprintf( stderr, " access=%08x,", req->access );
 739     fprintf( stderr, " inherit=%d", req->inherit );
 740 }
 741
 742 static void dump_open_process_reply( const struct open_process_reply *req )
 743 {
 744     fprintf( stderr, " handle=%p", req->handle );
 745 }
 746
 747 static void dump_open_thread_request( const struct open_thread_request *req )
 748 {
 749     fprintf( stderr, " tid=%04x,", req->tid );
 750     fprintf( stderr, " access=%08x,", req->access );
 751     fprintf( stderr, " inherit=%d", req->inherit );
 752 }
 753
 754 static void dump_open_thread_reply( const struct open_thread_reply *req )
 755 {
 756     fprintf( stderr, " handle=%p", req->handle );
 757 }
 758
 759 static void dump_select_request( const struct select_request *req )
 760 {
 761     fprintf( stderr, " flags=%d,", req->flags );
 762     fprintf( stderr, " cookie=%p,", req->cookie );
 763     fprintf( stderr, " timeout=" );
 764     dump_abs_time( &req->timeout );
 765     fprintf( stderr, "," );
 766     fprintf( stderr, " handles=" );
 767     dump_varargs_handles( cur_size );
 768 }
 769
 770 static void dump_create_event_request( const struct create_event_request *req )
 771 {
 772     fprintf( stderr, " access=%08x,", req->access );
 773     fprintf( stderr, " manual_reset=%d,", req->manual_reset );
 774     fprintf( stderr, " initial_state=%d,", req->initial_state );
 775     fprintf( stderr, " inherit=%d,", req->inherit );
 776     fprintf( stderr, " name=" );
 777     dump_varargs_unicode_str( cur_size );
 778 }
 779
 780 static void dump_create_event_reply( const struct create_event_reply *req )
 781 {
 782     fprintf( stderr, " handle=%p", req->handle );
 783 }
 784
 785 static void dump_event_op_request( const struct event_op_request *req )
 786 {
 787     fprintf( stderr, " handle=%p,", req->handle );
 788     fprintf( stderr, " op=%d", req->op );
 789 }
 790
 791 static void dump_open_event_request( const struct open_event_request *req )
 792 {
 793     fprintf( stderr, " access=%08x,", req->access );
 794     fprintf( stderr, " inherit=%d,", req->inherit );
 795     fprintf( stderr, " name=" );
 796     dump_varargs_unicode_str( cur_size );
 797 }
 798
 799 static void dump_open_event_reply( const struct open_event_reply *req )
 800 {
 801     fprintf( stderr, " handle=%p", req->handle );
 802 }
 803
 804 static void dump_create_mutex_request( const struct create_mutex_request *req )
 805 {
 806     fprintf( stderr, " access=%08x,", req->access );
 807     fprintf( stderr, " owned=%d,", req->owned );
 808     fprintf( stderr, " inherit=%d,", req->inherit );
 809     fprintf( stderr, " name=" );
 810     dump_varargs_unicode_str( cur_size );
 811 }
 812
 813 static void dump_create_mutex_reply( const struct create_mutex_reply *req )
 814 {
 815     fprintf( stderr, " handle=%p", req->handle );
 816 }
 817
 818 static void dump_release_mutex_request( const struct release_mutex_request *req )
 819 {
 820     fprintf( stderr, " handle=%p", req->handle );
 821 }
 822
 823 static void dump_release_mutex_reply( const struct release_mutex_reply *req )
 824 {
 825     fprintf( stderr, " prev_count=%08x", req->prev_count );
 826 }
 827
 828 static void dump_open_mutex_request( const struct open_mutex_request *req )
 829 {
 830     fprintf( stderr, " access=%08x,", req->access );
 831     fprintf( stderr, " inherit=%d,", req->inherit );
 832     fprintf( stderr, " name=" );
 833     dump_varargs_unicode_str( cur_size );
 834 }
 835
 836 static void dump_open_mutex_reply( const struct open_mutex_reply *req )
 837 {
 838     fprintf( stderr, " handle=%p", req->handle );
 839 }
 840
 841 static void dump_create_semaphore_request( const struct create_semaphore_request *req )
 842 {
 843     fprintf( stderr, " access=%08x,", req->access );
 844     fprintf( stderr, " initial=%08x,", req->initial );
 845     fprintf( stderr, " max=%08x,", req->max );
 846     fprintf( stderr, " inherit=%d,", req->inherit );
 847     fprintf( stderr, " name=" );
 848     dump_varargs_unicode_str( cur_size );
 849 }
 850
 851 static void dump_create_semaphore_reply( const struct create_semaphore_reply *req )
 852 {
 853     fprintf( stderr, " handle=%p", req->handle );
 854 }
 855
 856 static void dump_release_semaphore_request( const struct release_semaphore_request *req )
 857 {
 858     fprintf( stderr, " handle=%p,", req->handle );
 859     fprintf( stderr, " count=%08x", req->count );
 860 }
 861
 862 static void dump_release_semaphore_reply( const struct release_semaphore_reply *req )
 863 {
 864     fprintf( stderr, " prev_count=%08x", req->prev_count );
 865 }
 866
 867 static void dump_open_semaphore_request( const struct open_semaphore_request *req )
 868 {
 869     fprintf( stderr, " access=%08x,", req->access );
 870     fprintf( stderr, " inherit=%d,", req->inherit );
 871     fprintf( stderr, " name=" );
 872     dump_varargs_unicode_str( cur_size );
 873 }
 874
 875 static void dump_open_semaphore_reply( const struct open_semaphore_reply *req )
 876 {
 877     fprintf( stderr, " handle=%p", req->handle );
 878 }
 879
 880 static void dump_create_file_request( const struct create_file_request *req )
 881 {
 882     fprintf( stderr, " access=%08x,", req->access );
 883     fprintf( stderr, " inherit=%d,", req->inherit );
 884     fprintf( stderr, " sharing=%08x,", req->sharing );
 885     fprintf( stderr, " create=%d,", req->create );
 886     fprintf( stderr, " options=%08x,", req->options );
 887     fprintf( stderr, " attrs=%08x,", req->attrs );
 888     fprintf( stderr, " filename=" );
 889     dump_varargs_string( cur_size );
 890 }
 891
 892 static void dump_create_file_reply( const struct create_file_reply *req )
 893 {
 894     fprintf( stderr, " handle=%p", req->handle );
 895 }
 896
 897 static void dump_alloc_file_handle_request( const struct alloc_file_handle_request *req )
 898 {
 899     fprintf( stderr, " access=%08x,", req->access );
 900     fprintf( stderr, " inherit=%d,", req->inherit );
 901     fprintf( stderr, " fd=%d", req->fd );
 902 }
 903
 904 static void dump_alloc_file_handle_reply( const struct alloc_file_handle_reply *req )
 905 {
 906     fprintf( stderr, " handle=%p", req->handle );
 907 }
 908
 909 static void dump_get_handle_fd_request( const struct get_handle_fd_request *req )
 910 {
 911     fprintf( stderr, " handle=%p,", req->handle );
 912     fprintf( stderr, " access=%08x", req->access );
 913 }
 914
 915 static void dump_get_handle_fd_reply( const struct get_handle_fd_reply *req )
 916 {
 917     fprintf( stderr, " fd=%d,", req->fd );
 918     fprintf( stderr, " flags=%d", req->flags );
 919 }
 920
 921 static void dump_flush_file_request( const struct flush_file_request *req )
 922 {
 923     fprintf( stderr, " handle=%p", req->handle );
 924 }
 925
 926 static void dump_flush_file_reply( const struct flush_file_reply *req )
 927 {
 928     fprintf( stderr, " event=%p", req->event );
 929 }
 930
 931 static void dump_lock_file_request( const struct lock_file_request *req )
 932 {
 933     fprintf( stderr, " handle=%p,", req->handle );
 934     fprintf( stderr, " offset_low=%08x,", req->offset_low );
 935     fprintf( stderr, " offset_high=%08x,", req->offset_high );
 936     fprintf( stderr, " count_low=%08x,", req->count_low );
 937     fprintf( stderr, " count_high=%08x,", req->count_high );
 938     fprintf( stderr, " shared=%d,", req->shared );
 939     fprintf( stderr, " wait=%d", req->wait );
 940 }
 941
 942 static void dump_lock_file_reply( const struct lock_file_reply *req )
 943 {
 944     fprintf( stderr, " handle=%p,", req->handle );
 945     fprintf( stderr, " overlapped=%d", req->overlapped );
 946 }
 947
 948 static void dump_unlock_file_request( const struct unlock_file_request *req )
 949 {
 950     fprintf( stderr, " handle=%p,", req->handle );
 951     fprintf( stderr, " offset_low=%08x,", req->offset_low );
 952     fprintf( stderr, " offset_high=%08x,", req->offset_high );
 953     fprintf( stderr, " count_low=%08x,", req->count_low );
 954     fprintf( stderr, " count_high=%08x", req->count_high );
 955 }
 956
 957 static void dump_create_socket_request( const struct create_socket_request *req )
 958 {
 959     fprintf( stderr, " access=%08x,", req->access );
 960     fprintf( stderr, " inherit=%d,", req->inherit );
 961     fprintf( stderr, " family=%d,", req->family );
 962     fprintf( stderr, " type=%d,", req->type );
 963     fprintf( stderr, " protocol=%d,", req->protocol );
 964     fprintf( stderr, " flags=%08x", req->flags );
 965 }
 966
 967 static void dump_create_socket_reply( const struct create_socket_reply *req )
 968 {
 969     fprintf( stderr, " handle=%p", req->handle );
 970 }
 971
 972 static void dump_accept_socket_request( const struct accept_socket_request *req )
 973 {
 974     fprintf( stderr, " lhandle=%p,", req->lhandle );
 975     fprintf( stderr, " access=%08x,", req->access );
 976     fprintf( stderr, " inherit=%d", req->inherit );
 977 }
 978
 979 static void dump_accept_socket_reply( const struct accept_socket_reply *req )
 980 {
 981     fprintf( stderr, " handle=%p", req->handle );
 982 }
 983
 984 static void dump_set_socket_event_request( const struct set_socket_event_request *req )
 985 {
 986     fprintf( stderr, " handle=%p,", req->handle );
 987     fprintf( stderr, " mask=%08x,", req->mask );
 988     fprintf( stderr, " event=%p,", req->event );
 989     fprintf( stderr, " window=%p,", req->window );
 990     fprintf( stderr, " msg=%08x", req->msg );
 991 }
 992
 993 static void dump_get_socket_event_request( const struct get_socket_event_request *req )
 994 {
 995     fprintf( stderr, " handle=%p,", req->handle );
 996     fprintf( stderr, " service=%d,", req->service );
 997     fprintf( stderr, " c_event=%p", req->c_event );
 998 }
 999
1000 static void dump_get_socket_event_reply( const struct get_socket_event_reply *req )
1001 {
1002     fprintf( stderr, " mask=%08x,", req->mask );
1003     fprintf( stderr, " pmask=%08x,", req->pmask );
1004     fprintf( stderr, " state=%08x,", req->state );
1005     fprintf( stderr, " errors=" );
1006     dump_varargs_ints( cur_size );
1007 }
1008
1009 static void dump_enable_socket_event_request( const struct enable_socket_event_request *req )
1010 {
1011     fprintf( stderr, " handle=%p,", req->handle );
1012     fprintf( stderr, " mask=%08x,", req->mask );
1013     fprintf( stderr, " sstate=%08x,", req->sstate );
1014     fprintf( stderr, " cstate=%08x", req->cstate );
1015 }
1016
1017 static void dump_set_socket_deferred_request( const struct set_socket_deferred_request *req )
1018 {
1019     fprintf( stderr, " handle=%p,", req->handle );
1020     fprintf( stderr, " deferred=%p", req->deferred );
1021 }
1022
1023 static void dump_alloc_console_request( const struct alloc_console_request *req )
1024 {
1025     fprintf( stderr, " access=%08x,", req->access );
1026     fprintf( stderr, " inherit=%d,", req->inherit );
1027     fprintf( stderr, " pid=%04x", req->pid );
1028 }
1029
1030 static void dump_alloc_console_reply( const struct alloc_console_reply *req )
1031 {
1032     fprintf( stderr, " handle_in=%p,", req->handle_in );
1033     fprintf( stderr, " event=%p", req->event );
1034 }
1035
1036 static void dump_free_console_request( const struct free_console_request *req )
1037 {
1038 }
1039
1040 static void dump_get_console_renderer_events_request( const struct get_console_renderer_events_request *req )
1041 {
1042     fprintf( stderr, " handle=%p", req->handle );
1043 }
1044
1045 static void dump_get_console_renderer_events_reply( const struct get_console_renderer_events_reply *req )
1046 {
1047     fprintf( stderr, " data=" );
1048     dump_varargs_bytes( cur_size );
1049 }
1050
1051 static void dump_open_console_request( const struct open_console_request *req )
1052 {
1053     fprintf( stderr, " from=%d,", req->from );
1054     fprintf( stderr, " access=%08x,", req->access );
1055     fprintf( stderr, " inherit=%d,", req->inherit );
1056     fprintf( stderr, " share=%d", req->share );
1057 }
1058
1059 static void dump_open_console_reply( const struct open_console_reply *req )
1060 {
1061     fprintf( stderr, " handle=%p", req->handle );
1062 }
1063
1064 static void dump_get_console_wait_event_request( const struct get_console_wait_event_request *req )
1065 {
1066 }
1067
1068 static void dump_get_console_wait_event_reply( const struct get_console_wait_event_reply *req )
1069 {
1070     fprintf( stderr, " handle=%p", req->handle );
1071 }
1072
1073 static void dump_get_console_mode_request( const struct get_console_mode_request *req )
1074 {
1075     fprintf( stderr, " handle=%p", req->handle );
1076 }
1077
1078 static void dump_get_console_mode_reply( const struct get_console_mode_reply *req )
1079 {
1080     fprintf( stderr, " mode=%d", req->mode );
1081 }
1082
1083 static void dump_set_console_mode_request( const struct set_console_mode_request *req )
1084 {
1085     fprintf( stderr, " handle=%p,", req->handle );
1086     fprintf( stderr, " mode=%d", req->mode );
1087 }
1088
1089 static void dump_set_console_input_info_request( const struct set_console_input_info_request *req )
1090 {
1091     fprintf( stderr, " handle=%p,", req->handle );
1092     fprintf( stderr, " mask=%d,", req->mask );
1093     fprintf( stderr, " active_sb=%p,", req->active_sb );
1094     fprintf( stderr, " history_mode=%d,", req->history_mode );
1095     fprintf( stderr, " history_size=%d,", req->history_size );
1096     fprintf( stderr, " edition_mode=%d,", req->edition_mode );
1097     fprintf( stderr, " title=" );
1098     dump_varargs_unicode_str( cur_size );
1099 }
1100
1101 static void dump_get_console_input_info_request( const struct get_console_input_info_request *req )
1102 {
1103     fprintf( stderr, " handle=%p", req->handle );
1104 }
1105
1106 static void dump_get_console_input_info_reply( const struct get_console_input_info_reply *req )
1107 {
1108     fprintf( stderr, " history_mode=%d,", req->history_mode );
1109     fprintf( stderr, " history_size=%d,", req->history_size );
1110     fprintf( stderr, " history_index=%d,", req->history_index );
1111     fprintf( stderr, " edition_mode=%d,", req->edition_mode );
1112     fprintf( stderr, " title=" );
1113     dump_varargs_unicode_str( cur_size );
1114 }
1115
1116 static void dump_append_console_input_history_request( const struct append_console_input_history_request *req )
1117 {
1118     fprintf( stderr, " handle=%p,", req->handle );
1119     fprintf( stderr, " line=" );
1120     dump_varargs_unicode_str( cur_size );
1121 }
1122
1123 static void dump_get_console_input_history_request( const struct get_console_input_history_request *req )
1124 {
1125     fprintf( stderr, " handle=%p,", req->handle );
1126     fprintf( stderr, " index=%d", req->index );
1127 }
1128
1129 static void dump_get_console_input_history_reply( const struct get_console_input_history_reply *req )
1130 {
1131     fprintf( stderr, " total=%d,", req->total );
1132     fprintf( stderr, " line=" );
1133     dump_varargs_unicode_str( cur_size );
1134 }
1135
1136 static void dump_create_console_output_request( const struct create_console_output_request *req )
1137 {
1138     fprintf( stderr, " handle_in=%p,", req->handle_in );
1139     fprintf( stderr, " access=%d,", req->access );
1140     fprintf( stderr, " share=%d,", req->share );
1141     fprintf( stderr, " inherit=%d", req->inherit );
1142 }
1143
1144 static void dump_create_console_output_reply( const struct create_console_output_reply *req )
1145 {
1146     fprintf( stderr, " handle_out=%p", req->handle_out );
1147 }
1148
1149 static void dump_set_console_output_info_request( const struct set_console_output_info_request *req )
1150 {
1151     fprintf( stderr, " handle=%p,", req->handle );
1152     fprintf( stderr, " mask=%d,", req->mask );
1153     fprintf( stderr, " cursor_size=%d,", req->cursor_size );
1154     fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
1155     fprintf( stderr, " cursor_x=%d,", req->cursor_x );
1156     fprintf( stderr, " cursor_y=%d,", req->cursor_y );
1157     fprintf( stderr, " width=%d,", req->width );
1158     fprintf( stderr, " height=%d,", req->height );
1159     fprintf( stderr, " attr=%d,", req->attr );
1160     fprintf( stderr, " win_left=%d,", req->win_left );
1161     fprintf( stderr, " win_top=%d,", req->win_top );
1162     fprintf( stderr, " win_right=%d,", req->win_right );
1163     fprintf( stderr, " win_bottom=%d,", req->win_bottom );
1164     fprintf( stderr, " max_width=%d,", req->max_width );
1165     fprintf( stderr, " max_height=%d", req->max_height );
1166 }
1167
1168 static void dump_get_console_output_info_request( const struct get_console_output_info_request *req )
1169 {
1170     fprintf( stderr, " handle=%p", req->handle );
1171 }
1172
1173 static void dump_get_console_output_info_reply( const struct get_console_output_info_reply *req )
1174 {
1175     fprintf( stderr, " cursor_size=%d,", req->cursor_size );
1176     fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
1177     fprintf( stderr, " cursor_x=%d,", req->cursor_x );
1178     fprintf( stderr, " cursor_y=%d,", req->cursor_y );
1179     fprintf( stderr, " width=%d,", req->width );
1180     fprintf( stderr, " height=%d,", req->height );
1181     fprintf( stderr, " attr=%d,", req->attr );
1182     fprintf( stderr, " win_left=%d,", req->win_left );
1183     fprintf( stderr, " win_top=%d,", req->win_top );
1184     fprintf( stderr, " win_right=%d,", req->win_right );
1185     fprintf( stderr, " win_bottom=%d,", req->win_bottom );
1186     fprintf( stderr, " max_width=%d,", req->max_width );
1187     fprintf( stderr, " max_height=%d", req->max_height );
1188 }
1189
1190 static void dump_write_console_input_request( const struct write_console_input_request *req )
1191 {
1192     fprintf( stderr, " handle=%p,", req->handle );
1193     fprintf( stderr, " rec=" );
1194     dump_varargs_input_records( cur_size );
1195 }
1196
1197 static void dump_write_console_input_reply( const struct write_console_input_reply *req )
1198 {
1199     fprintf( stderr, " written=%d", req->written );
1200 }
1201
1202 static void dump_read_console_input_request( const struct read_console_input_request *req )
1203 {
1204     fprintf( stderr, " handle=%p,", req->handle );
1205     fprintf( stderr, " flush=%d", req->flush );
1206 }
1207
1208 static void dump_read_console_input_reply( const struct read_console_input_reply *req )
1209 {
1210     fprintf( stderr, " read=%d,", req->read );
1211     fprintf( stderr, " rec=" );
1212     dump_varargs_input_records( cur_size );
1213 }
1214
1215 static void dump_write_console_output_request( const struct write_console_output_request *req )
1216 {
1217     fprintf( stderr, " handle=%p,", req->handle );
1218     fprintf( stderr, " x=%d,", req->x );
1219     fprintf( stderr, " y=%d,", req->y );
1220     fprintf( stderr, " mode=%d,", req->mode );
1221     fprintf( stderr, " wrap=%d,", req->wrap );
1222     fprintf( stderr, " data=" );
1223     dump_varargs_bytes( cur_size );
1224 }
1225
1226 static void dump_write_console_output_reply( const struct write_console_output_reply *req )
1227 {
1228     fprintf( stderr, " written=%d,", req->written );
1229     fprintf( stderr, " width=%d,", req->width );
1230     fprintf( stderr, " height=%d", req->height );
1231 }
1232
1233 static void dump_fill_console_output_request( const struct fill_console_output_request *req )
1234 {
1235     fprintf( stderr, " handle=%p,", req->handle );
1236     fprintf( stderr, " x=%d,", req->x );
1237     fprintf( stderr, " y=%d,", req->y );
1238     fprintf( stderr, " mode=%d,", req->mode );
1239     fprintf( stderr, " count=%d,", req->count );
1240     fprintf( stderr, " wrap=%d,", req->wrap );
1241     fprintf( stderr, " data=" );
1242     dump_char_info( &req->data );
1243 }
1244
1245 static void dump_fill_console_output_reply( const struct fill_console_output_reply *req )
1246 {
1247     fprintf( stderr, " written=%d", req->written );
1248 }
1249
1250 static void dump_read_console_output_request( const struct read_console_output_request *req )
1251 {
1252     fprintf( stderr, " handle=%p,", req->handle );
1253     fprintf( stderr, " x=%d,", req->x );
1254     fprintf( stderr, " y=%d,", req->y );
1255     fprintf( stderr, " mode=%d,", req->mode );
1256     fprintf( stderr, " wrap=%d", req->wrap );
1257 }
1258
1259 static void dump_read_console_output_reply( const struct read_console_output_reply *req )
1260 {
1261     fprintf( stderr, " width=%d,", req->width );
1262     fprintf( stderr, " height=%d,", req->height );
1263     fprintf( stderr, " data=" );
1264     dump_varargs_bytes( cur_size );
1265 }
1266
1267 static void dump_move_console_output_request( const struct move_console_output_request *req )
1268 {
1269     fprintf( stderr, " handle=%p,", req->handle );
1270     fprintf( stderr, " x_src=%d,", req->x_src );
1271     fprintf( stderr, " y_src=%d,", req->y_src );
1272     fprintf( stderr, " x_dst=%d,", req->x_dst );
1273     fprintf( stderr, " y_dst=%d,", req->y_dst );
1274     fprintf( stderr, " w=%d,", req->w );
1275     fprintf( stderr, " h=%d", req->h );
1276 }
1277
1278 static void dump_send_console_signal_request( const struct send_console_signal_request *req )
1279 {
1280     fprintf( stderr, " signal=%d,", req->signal );
1281     fprintf( stderr, " group_id=%04x", req->group_id );
1282 }
1283
1284 static void dump_create_change_notification_request( const struct create_change_notification_request *req )
1285 {
1286     fprintf( stderr, " handle=%p,", req->handle );
1287     fprintf( stderr, " subtree=%d,", req->subtree );
1288     fprintf( stderr, " filter=%08x", req->filter );
1289 }
1290
1291 static void dump_create_change_notification_reply( const struct create_change_notification_reply *req )
1292 {
1293     fprintf( stderr, " handle=%p", req->handle );
1294 }
1295
1296 static void dump_next_change_notification_request( const struct next_change_notification_request *req )
1297 {
1298     fprintf( stderr, " handle=%p", req->handle );
1299 }
1300
1301 static void dump_create_mapping_request( const struct create_mapping_request *req )
1302 {
1303     fprintf( stderr, " size_high=%d,", req->size_high );
1304     fprintf( stderr, " size_low=%d,", req->size_low );
1305     fprintf( stderr, " protect=%d,", req->protect );
1306     fprintf( stderr, " access=%08x,", req->access );
1307     fprintf( stderr, " inherit=%d,", req->inherit );
1308     fprintf( stderr, " file_handle=%p,", req->file_handle );
1309     fprintf( stderr, " name=" );
1310     dump_varargs_unicode_str( cur_size );
1311 }
1312
1313 static void dump_create_mapping_reply( const struct create_mapping_reply *req )
1314 {
1315     fprintf( stderr, " handle=%p", req->handle );
1316 }
1317
1318 static void dump_open_mapping_request( const struct open_mapping_request *req )
1319 {
1320     fprintf( stderr, " access=%08x,", req->access );
1321     fprintf( stderr, " inherit=%d,", req->inherit );
1322     fprintf( stderr, " name=" );
1323     dump_varargs_unicode_str( cur_size );
1324 }
1325
1326 static void dump_open_mapping_reply( const struct open_mapping_reply *req )
1327 {
1328     fprintf( stderr, " handle=%p", req->handle );
1329 }
1330
1331 static void dump_get_mapping_info_request( const struct get_mapping_info_request *req )
1332 {
1333     fprintf( stderr, " handle=%p", req->handle );
1334 }
1335
1336 static void dump_get_mapping_info_reply( const struct get_mapping_info_reply *req )
1337 {
1338     fprintf( stderr, " size_high=%d,", req->size_high );
1339     fprintf( stderr, " size_low=%d,", req->size_low );
1340     fprintf( stderr, " protect=%d,", req->protect );
1341     fprintf( stderr, " header_size=%d,", req->header_size );
1342     fprintf( stderr, " base=%p,", req->base );
1343     fprintf( stderr, " shared_file=%p,", req->shared_file );
1344     fprintf( stderr, " shared_size=%d", req->shared_size );
1345 }
1346
1347 static void dump_create_snapshot_request( const struct create_snapshot_request *req )
1348 {
1349     fprintf( stderr, " inherit=%d,", req->inherit );
1350     fprintf( stderr, " flags=%d,", req->flags );
1351     fprintf( stderr, " pid=%04x", req->pid );
1352 }
1353
1354 static void dump_create_snapshot_reply( const struct create_snapshot_reply *req )
1355 {
1356     fprintf( stderr, " handle=%p", req->handle );
1357 }
1358
1359 static void dump_next_process_request( const struct next_process_request *req )
1360 {
1361     fprintf( stderr, " handle=%p,", req->handle );
1362     fprintf( stderr, " reset=%d", req->reset );
1363 }
1364
1365 static void dump_next_process_reply( const struct next_process_reply *req )
1366 {
1367     fprintf( stderr, " count=%d,", req->count );
1368     fprintf( stderr, " pid=%04x,", req->pid );
1369     fprintf( stderr, " ppid=%04x,", req->ppid );
1370     fprintf( stderr, " heap=%p,", req->heap );
1371     fprintf( stderr, " module=%p,", req->module );
1372     fprintf( stderr, " threads=%d,", req->threads );
1373     fprintf( stderr, " priority=%d,", req->priority );
1374     fprintf( stderr, " handles=%d,", req->handles );
1375     fprintf( stderr, " filename=" );
1376     dump_varargs_unicode_str( cur_size );
1377 }
1378
1379 static void dump_next_thread_request( const struct next_thread_request *req )
1380 {
1381     fprintf( stderr, " handle=%p,", req->handle );
1382     fprintf( stderr, " reset=%d", req->reset );
1383 }
1384
1385 static void dump_next_thread_reply( const struct next_thread_reply *req )
1386 {
1387     fprintf( stderr, " count=%d,", req->count );
1388     fprintf( stderr, " pid=%04x,", req->pid );
1389     fprintf( stderr, " tid=%04x,", req->tid );
1390     fprintf( stderr, " base_pri=%d,", req->base_pri );
1391     fprintf( stderr, " delta_pri=%d", req->delta_pri );
1392 }
1393
1394 static void dump_next_module_request( const struct next_module_request *req )
1395 {
1396     fprintf( stderr, " handle=%p,", req->handle );
1397     fprintf( stderr, " reset=%d", req->reset );
1398 }
1399
1400 static void dump_next_module_reply( const struct next_module_reply *req )
1401 {
1402     fprintf( stderr, " pid=%04x,", req->pid );
1403     fprintf( stderr, " base=%p,", req->base );
1404     fprintf( stderr, " size=%d,", req->size );
1405     fprintf( stderr, " filename=" );
1406     dump_varargs_unicode_str( cur_size );
1407 }
1408
1409 static void dump_wait_debug_event_request( const struct wait_debug_event_request *req )
1410 {
1411     fprintf( stderr, " get_handle=%d", req->get_handle );
1412 }
1413
1414 static void dump_wait_debug_event_reply( const struct wait_debug_event_reply *req )
1415 {
1416     fprintf( stderr, " pid=%04x,", req->pid );
1417     fprintf( stderr, " tid=%04x,", req->tid );
1418     fprintf( stderr, " wait=%p,", req->wait );
1419     fprintf( stderr, " event=" );
1420     dump_varargs_debug_event( cur_size );
1421 }
1422
1423 static void dump_queue_exception_event_request( const struct queue_exception_event_request *req )
1424 {
1425     fprintf( stderr, " first=%d,", req->first );
1426     fprintf( stderr, " record=" );
1427     dump_varargs_exc_event( cur_size );
1428 }
1429
1430 static void dump_queue_exception_event_reply( const struct queue_exception_event_reply *req )
1431 {
1432     fprintf( stderr, " handle=%p", req->handle );
1433 }
1434
1435 static void dump_get_exception_status_request( const struct get_exception_status_request *req )
1436 {
1437     fprintf( stderr, " handle=%p", req->handle );
1438 }
1439
1440 static void dump_get_exception_status_reply( const struct get_exception_status_reply *req )
1441 {
1442     fprintf( stderr, " status=%d,", req->status );
1443     fprintf( stderr, " context=" );
1444     dump_varargs_context( cur_size );
1445 }
1446
1447 static void dump_output_debug_string_request( const struct output_debug_string_request *req )
1448 {
1449     fprintf( stderr, " string=%p,", req->string );
1450     fprintf( stderr, " unicode=%d,", req->unicode );
1451     fprintf( stderr, " length=%d", req->length );
1452 }
1453
1454 static void dump_continue_debug_event_request( const struct continue_debug_event_request *req )
1455 {
1456     fprintf( stderr, " pid=%04x,", req->pid );
1457     fprintf( stderr, " tid=%04x,", req->tid );
1458     fprintf( stderr, " status=%d", req->status );
1459 }
1460
1461 static void dump_debug_process_request( const struct debug_process_request *req )
1462 {
1463     fprintf( stderr, " pid=%04x,", req->pid );
1464     fprintf( stderr, " attach=%d", req->attach );
1465 }
1466
1467 static void dump_debug_break_request( const struct debug_break_request *req )
1468 {
1469     fprintf( stderr, " handle=%p", req->handle );
1470 }
1471
1472 static void dump_debug_break_reply( const struct debug_break_reply *req )
1473 {
1474     fprintf( stderr, " self=%d", req->self );
1475 }
1476
1477 static void dump_set_debugger_kill_on_exit_request( const struct set_debugger_kill_on_exit_request *req )
1478 {
1479     fprintf( stderr, " kill_on_exit=%d", req->kill_on_exit );
1480 }
1481
1482 static void dump_read_process_memory_request( const struct read_process_memory_request *req )
1483 {
1484     fprintf( stderr, " handle=%p,", req->handle );
1485     fprintf( stderr, " addr=%p", req->addr );
1486 }
1487
1488 static void dump_read_process_memory_reply( const struct read_process_memory_reply *req )
1489 {
1490     fprintf( stderr, " data=" );
1491     dump_varargs_bytes( cur_size );
1492 }
1493
1494 static void dump_write_process_memory_request( const struct write_process_memory_request *req )
1495 {
1496     fprintf( stderr, " handle=%p,", req->handle );
1497     fprintf( stderr, " addr=%p,", req->addr );
1498     fprintf( stderr, " first_mask=%08x,", req->first_mask );
1499     fprintf( stderr, " last_mask=%08x,", req->last_mask );
1500     fprintf( stderr, " data=" );
1501     dump_varargs_bytes( cur_size );
1502 }
1503
1504 static void dump_create_key_request( const struct create_key_request *req )
1505 {
1506     fprintf( stderr, " parent=%p,", req->parent );
1507     fprintf( stderr, " access=%08x,", req->access );
1508     fprintf( stderr, " options=%08x,", req->options );
1509     fprintf( stderr, " modif=%ld,", (long)req->modif );
1510     fprintf( stderr, " namelen=%d,", req->namelen );
1511     fprintf( stderr, " name=" );
1512     dump_varargs_unicode_str( min(cur_size,req->namelen) );
1513     fputc( ',', stderr );
1514     fprintf( stderr, " class=" );
1515     dump_varargs_unicode_str( cur_size );
1516 }
1517
1518 static void dump_create_key_reply( const struct create_key_reply *req )
1519 {
1520     fprintf( stderr, " hkey=%p,", req->hkey );
1521     fprintf( stderr, " created=%d", req->created );
1522 }
1523
1524 static void dump_open_key_request( const struct open_key_request *req )
1525 {
1526     fprintf( stderr, " parent=%p,", req->parent );
1527     fprintf( stderr, " access=%08x,", req->access );
1528     fprintf( stderr, " name=" );
1529     dump_varargs_unicode_str( cur_size );
1530 }
1531
1532 static void dump_open_key_reply( const struct open_key_reply *req )
1533 {
1534     fprintf( stderr, " hkey=%p", req->hkey );
1535 }
1536
1537 static void dump_delete_key_request( const struct delete_key_request *req )
1538 {
1539     fprintf( stderr, " hkey=%p", req->hkey );
1540 }
1541
1542 static void dump_flush_key_request( const struct flush_key_request *req )
1543 {
1544     fprintf( stderr, " hkey=%p", req->hkey );
1545 }
1546
1547 static void dump_enum_key_request( const struct enum_key_request *req )
1548 {
1549     fprintf( stderr, " hkey=%p,", req->hkey );
1550     fprintf( stderr, " index=%d,", req->index );
1551     fprintf( stderr, " info_class=%d", req->info_class );
1552 }
1553
1554 static void dump_enum_key_reply( const struct enum_key_reply *req )
1555 {
1556     fprintf( stderr, " subkeys=%d,", req->subkeys );
1557     fprintf( stderr, " max_subkey=%d,", req->max_subkey );
1558     fprintf( stderr, " max_class=%d,", req->max_class );
1559     fprintf( stderr, " values=%d,", req->values );
1560     fprintf( stderr, " max_value=%d,", req->max_value );
1561     fprintf( stderr, " max_data=%d,", req->max_data );
1562     fprintf( stderr, " modif=%ld,", (long)req->modif );
1563     fprintf( stderr, " total=%d,", req->total );
1564     fprintf( stderr, " namelen=%d,", req->namelen );
1565     fprintf( stderr, " name=" );
1566     dump_varargs_unicode_str( min(cur_size,req->namelen) );
1567     fputc( ',', stderr );
1568     fprintf( stderr, " class=" );
1569     dump_varargs_unicode_str( cur_size );
1570 }
1571
1572 static void dump_set_key_value_request( const struct set_key_value_request *req )
1573 {
1574     fprintf( stderr, " hkey=%p,", req->hkey );
1575     fprintf( stderr, " type=%d,", req->type );
1576     fprintf( stderr, " namelen=%d,", req->namelen );
1577     fprintf( stderr, " name=" );
1578     dump_varargs_unicode_str( min(cur_size,req->namelen) );
1579     fputc( ',', stderr );
1580     fprintf( stderr, " data=" );
1581     dump_varargs_bytes( cur_size );
1582 }
1583
1584 static void dump_get_key_value_request( const struct get_key_value_request *req )
1585 {
1586     fprintf( stderr, " hkey=%p,", req->hkey );
1587     fprintf( stderr, " name=" );
1588     dump_varargs_unicode_str( cur_size );
1589 }
1590
1591 static void dump_get_key_value_reply( const struct get_key_value_reply *req )
1592 {
1593     fprintf( stderr, " type=%d,", req->type );
1594     fprintf( stderr, " total=%d,", req->total );
1595     fprintf( stderr, " data=" );
1596     dump_varargs_bytes( cur_size );
1597 }
1598
1599 static void dump_enum_key_value_request( const struct enum_key_value_request *req )
1600 {
1601     fprintf( stderr, " hkey=%p,", req->hkey );
1602     fprintf( stderr, " index=%d,", req->index );
1603     fprintf( stderr, " info_class=%d", req->info_class );
1604 }
1605
1606 static void dump_enum_key_value_reply( const struct enum_key_value_reply *req )
1607 {
1608     fprintf( stderr, " type=%d,", req->type );
1609     fprintf( stderr, " total=%d,", req->total );
1610     fprintf( stderr, " namelen=%d,", req->namelen );
1611     fprintf( stderr, " name=" );
1612     dump_varargs_unicode_str( min(cur_size,req->namelen) );
1613     fputc( ',', stderr );
1614     fprintf( stderr, " data=" );
1615     dump_varargs_bytes( cur_size );
1616 }
1617
1618 static void dump_delete_key_value_request( const struct delete_key_value_request *req )
1619 {
1620     fprintf( stderr, " hkey=%p,", req->hkey );
1621     fprintf( stderr, " name=" );
1622     dump_varargs_unicode_str( cur_size );
1623 }
1624
1625 static void dump_load_registry_request( const struct load_registry_request *req )
1626 {
1627     fprintf( stderr, " hkey=%p,", req->hkey );
1628     fprintf( stderr, " file=%p,", req->file );
1629     fprintf( stderr, " name=" );
1630     dump_varargs_unicode_str( cur_size );
1631 }
1632
1633 static void dump_unload_registry_request( const struct unload_registry_request *req )
1634 {
1635     fprintf( stderr, " hkey=%p", req->hkey );
1636 }
1637
1638 static void dump_save_registry_request( const struct save_registry_request *req )
1639 {
1640     fprintf( stderr, " hkey=%p,", req->hkey );
1641     fprintf( stderr, " file=%p", req->file );
1642 }
1643
1644 static void dump_load_user_registries_request( const struct load_user_registries_request *req )
1645 {
1646     fprintf( stderr, " hkey=%p,", req->hkey );
1647     fprintf( stderr, " saving=%d,", req->saving );
1648     fprintf( stderr, " period=%d", req->period );
1649 }
1650
1651 static void dump_set_registry_notification_request( const struct set_registry_notification_request *req )
1652 {
1653     fprintf( stderr, " hkey=%p,", req->hkey );
1654     fprintf( stderr, " event=%p,", req->event );
1655     fprintf( stderr, " subtree=%d,", req->subtree );
1656     fprintf( stderr, " filter=%08x", req->filter );
1657 }
1658
1659 static void dump_create_timer_request( const struct create_timer_request *req )
1660 {
1661     fprintf( stderr, " access=%08x,", req->access );
1662     fprintf( stderr, " inherit=%d,", req->inherit );
1663     fprintf( stderr, " manual=%d,", req->manual );
1664     fprintf( stderr, " name=" );
1665     dump_varargs_unicode_str( cur_size );
1666 }
1667
1668 static void dump_create_timer_reply( const struct create_timer_reply *req )
1669 {
1670     fprintf( stderr, " handle=%p", req->handle );
1671 }
1672
1673 static void dump_open_timer_request( const struct open_timer_request *req )
1674 {
1675     fprintf( stderr, " access=%08x,", req->access );
1676     fprintf( stderr, " inherit=%d,", req->inherit );
1677     fprintf( stderr, " name=" );
1678     dump_varargs_unicode_str( cur_size );
1679 }
1680
1681 static void dump_open_timer_reply( const struct open_timer_reply *req )
1682 {
1683     fprintf( stderr, " handle=%p", req->handle );
1684 }
1685
1686 static void dump_set_timer_request( const struct set_timer_request *req )
1687 {
1688     fprintf( stderr, " handle=%p,", req->handle );
1689     fprintf( stderr, " expire=" );
1690     dump_abs_time( &req->expire );
1691     fprintf( stderr, "," );
1692     fprintf( stderr, " period=%d,", req->period );
1693     fprintf( stderr, " callback=%p,", req->callback );
1694     fprintf( stderr, " arg=%p", req->arg );
1695 }
1696
1697 static void dump_set_timer_reply( const struct set_timer_reply *req )
1698 {
1699     fprintf( stderr, " signaled=%d", req->signaled );
1700 }
1701
1702 static void dump_cancel_timer_request( const struct cancel_timer_request *req )
1703 {
1704     fprintf( stderr, " handle=%p", req->handle );
1705 }
1706
1707 static void dump_cancel_timer_reply( const struct cancel_timer_reply *req )
1708 {
1709     fprintf( stderr, " signaled=%d", req->signaled );
1710 }
1711
1712 static void dump_get_timer_info_request( const struct get_timer_info_request *req )
1713 {
1714     fprintf( stderr, " handle=%p", req->handle );
1715 }
1716
1717 static void dump_get_timer_info_reply( const struct get_timer_info_reply *req )
1718 {
1719     fprintf( stderr, " when=" );
1720     dump_abs_time( &req->when );
1721     fprintf( stderr, "," );
1722     fprintf( stderr, " signaled=%d", req->signaled );
1723 }
1724
1725 static void dump_get_thread_context_request( const struct get_thread_context_request *req )
1726 {
1727     fprintf( stderr, " handle=%p,", req->handle );
1728     fprintf( stderr, " flags=%08x", req->flags );
1729 }
1730
1731 static void dump_get_thread_context_reply( const struct get_thread_context_reply *req )
1732 {
1733     fprintf( stderr, " context=" );
1734     dump_varargs_context( cur_size );
1735 }
1736
1737 static void dump_set_thread_context_request( const struct set_thread_context_request *req )
1738 {
1739     fprintf( stderr, " handle=%p,", req->handle );
1740     fprintf( stderr, " flags=%08x,", req->flags );
1741     fprintf( stderr, " context=" );
1742     dump_varargs_context( cur_size );
1743 }
1744
1745 static void dump_get_selector_entry_request( const struct get_selector_entry_request *req )
1746 {
1747     fprintf( stderr, " handle=%p,", req->handle );
1748     fprintf( stderr, " entry=%d", req->entry );
1749 }
1750
1751 static void dump_get_selector_entry_reply( const struct get_selector_entry_reply *req )
1752 {
1753     fprintf( stderr, " base=%08x,", req->base );
1754     fprintf( stderr, " limit=%08x,", req->limit );
1755     fprintf( stderr, " flags=%02x", req->flags );
1756 }
1757
1758 static void dump_add_atom_request( const struct add_atom_request *req )
1759 {
1760     fprintf( stderr, " local=%d,", req->local );
1761     fprintf( stderr, " name=" );
1762     dump_varargs_unicode_str( cur_size );
1763 }
1764
1765 static void dump_add_atom_reply( const struct add_atom_reply *req )
1766 {
1767     fprintf( stderr, " atom=%04x", req->atom );
1768 }
1769
1770 static void dump_delete_atom_request( const struct delete_atom_request *req )
1771 {
1772     fprintf( stderr, " atom=%04x,", req->atom );
1773     fprintf( stderr, " local=%d", req->local );
1774 }
1775
1776 static void dump_find_atom_request( const struct find_atom_request *req )
1777 {
1778     fprintf( stderr, " local=%d,", req->local );
1779     fprintf( stderr, " name=" );
1780     dump_varargs_unicode_str( cur_size );
1781 }
1782
1783 static void dump_find_atom_reply( const struct find_atom_reply *req )
1784 {
1785     fprintf( stderr, " atom=%04x", req->atom );
1786 }
1787
1788 static void dump_get_atom_name_request( const struct get_atom_name_request *req )
1789 {
1790     fprintf( stderr, " atom=%04x,", req->atom );
1791     fprintf( stderr, " local=%d", req->local );
1792 }
1793
1794 static void dump_get_atom_name_reply( const struct get_atom_name_reply *req )
1795 {
1796     fprintf( stderr, " count=%d,", req->count );
1797     fprintf( stderr, " name=" );
1798     dump_varargs_unicode_str( cur_size );
1799 }
1800
1801 static void dump_init_atom_table_request( const struct init_atom_table_request *req )
1802 {
1803     fprintf( stderr, " entries=%d", req->entries );
1804 }
1805
1806 static void dump_get_msg_queue_request( const struct get_msg_queue_request *req )
1807 {
1808 }
1809
1810 static void dump_get_msg_queue_reply( const struct get_msg_queue_reply *req )
1811 {
1812     fprintf( stderr, " handle=%p", req->handle );
1813 }
1814
1815 static void dump_set_queue_mask_request( const struct set_queue_mask_request *req )
1816 {
1817     fprintf( stderr, " wake_mask=%08x,", req->wake_mask );
1818     fprintf( stderr, " changed_mask=%08x,", req->changed_mask );
1819     fprintf( stderr, " skip_wait=%d", req->skip_wait );
1820 }
1821
1822 static void dump_set_queue_mask_reply( const struct set_queue_mask_reply *req )
1823 {
1824     fprintf( stderr, " wake_bits=%08x,", req->wake_bits );
1825     fprintf( stderr, " changed_bits=%08x", req->changed_bits );
1826 }
1827
1828 static void dump_get_queue_status_request( const struct get_queue_status_request *req )
1829 {
1830     fprintf( stderr, " clear=%d", req->clear );
1831 }
1832
1833 static void dump_get_queue_status_reply( const struct get_queue_status_reply *req )
1834 {
1835     fprintf( stderr, " wake_bits=%08x,", req->wake_bits );
1836     fprintf( stderr, " changed_bits=%08x", req->changed_bits );
1837 }
1838
1839 static void dump_wait_input_idle_request( const struct wait_input_idle_request *req )
1840 {
1841     fprintf( stderr, " handle=%p,", req->handle );
1842     fprintf( stderr, " timeout=%d", req->timeout );
1843 }
1844
1845 static void dump_wait_input_idle_reply( const struct wait_input_idle_reply *req )
1846 {
1847     fprintf( stderr, " event=%p", req->event );
1848 }
1849
1850 static void dump_send_message_request( const struct send_message_request *req )
1851 {
1852     fprintf( stderr, " id=%04x,", req->id );
1853     fprintf( stderr, " type=%d,", req->type );
1854     fprintf( stderr, " flags=%d,", req->flags );
1855     fprintf( stderr, " win=%p,", req->win );
1856     fprintf( stderr, " msg=%08x,", req->msg );
1857     fprintf( stderr, " wparam=%08x,", req->wparam );
1858     fprintf( stderr, " lparam=%08x,", req->lparam );
1859     fprintf( stderr, " x=%d,", req->x );
1860     fprintf( stderr, " y=%d,", req->y );
1861     fprintf( stderr, " time=%08x,", req->time );
1862     fprintf( stderr, " info=%08x,", req->info );
1863     fprintf( stderr, " timeout=%d,", req->timeout );
1864     fprintf( stderr, " callback=%p,", req->callback );
1865     fprintf( stderr, " data=" );
1866     dump_varargs_bytes( cur_size );
1867 }
1868
1869 static void dump_get_message_request( const struct get_message_request *req )
1870 {
1871     fprintf( stderr, " flags=%d,", req->flags );
1872     fprintf( stderr, " get_win=%p,", req->get_win );
1873     fprintf( stderr, " get_first=%08x,", req->get_first );
1874     fprintf( stderr, " get_last=%08x,", req->get_last );
1875     fprintf( stderr, " get_next_hw=%d", req->get_next_hw );
1876 }
1877
1878 static void dump_get_message_reply( const struct get_message_reply *req )
1879 {
1880     fprintf( stderr, " type=%d,", req->type );
1881     fprintf( stderr, " win=%p,", req->win );
1882     fprintf( stderr, " msg=%08x,", req->msg );
1883     fprintf( stderr, " wparam=%08x,", req->wparam );
1884     fprintf( stderr, " lparam=%08x,", req->lparam );
1885     fprintf( stderr, " x=%d,", req->x );
1886     fprintf( stderr, " y=%d,", req->y );
1887     fprintf( stderr, " hook=%p,", req->hook );
1888     fprintf( stderr, " hook_proc=%p,", req->hook_proc );
1889     fprintf( stderr, " time=%08x,", req->time );
1890     fprintf( stderr, " info=%08x,", req->info );
1891     fprintf( stderr, " total=%d,", req->total );
1892     fprintf( stderr, " data=" );
1893     dump_varargs_bytes( cur_size );
1894 }
1895
1896 static void dump_reply_message_request( const struct reply_message_request *req )
1897 {
1898     fprintf( stderr, " type=%d,", req->type );
1899     fprintf( stderr, " result=%08x,", req->result );
1900     fprintf( stderr, " remove=%d,", req->remove );
1901     fprintf( stderr, " data=" );
1902     dump_varargs_bytes( cur_size );
1903 }
1904
1905 static void dump_get_message_reply_request( const struct get_message_reply_request *req )
1906 {
1907     fprintf( stderr, " cancel=%d", req->cancel );
1908 }
1909
1910 static void dump_get_message_reply_reply( const struct get_message_reply_reply *req )
1911 {
1912     fprintf( stderr, " result=%08x,", req->result );
1913     fprintf( stderr, " data=" );
1914     dump_varargs_bytes( cur_size );
1915 }
1916
1917 static void dump_set_win_timer_request( const struct set_win_timer_request *req )
1918 {
1919     fprintf( stderr, " win=%p,", req->win );
1920     fprintf( stderr, " msg=%08x,", req->msg );
1921     fprintf( stderr, " id=%08x,", req->id );
1922     fprintf( stderr, " rate=%08x,", req->rate );
1923     fprintf( stderr, " lparam=%08x", req->lparam );
1924 }
1925
1926 static void dump_set_win_timer_reply( const struct set_win_timer_reply *req )
1927 {
1928     fprintf( stderr, " id=%08x", req->id );
1929 }
1930
1931 static void dump_kill_win_timer_request( const struct kill_win_timer_request *req )
1932 {
1933     fprintf( stderr, " win=%p,", req->win );
1934     fprintf( stderr, " msg=%08x,", req->msg );
1935     fprintf( stderr, " id=%08x", req->id );
1936 }
1937
1938 static void dump_get_serial_info_request( const struct get_serial_info_request *req )
1939 {
1940     fprintf( stderr, " handle=%p", req->handle );
1941 }
1942
1943 static void dump_get_serial_info_reply( const struct get_serial_info_reply *req )
1944 {
1945     fprintf( stderr, " readinterval=%08x,", req->readinterval );
1946     fprintf( stderr, " readconst=%08x,", req->readconst );
1947     fprintf( stderr, " readmult=%08x,", req->readmult );
1948     fprintf( stderr, " writeconst=%08x,", req->writeconst );
1949     fprintf( stderr, " writemult=%08x,", req->writemult );
1950     fprintf( stderr, " eventmask=%08x,", req->eventmask );
1951     fprintf( stderr, " commerror=%08x", req->commerror );
1952 }
1953
1954 static void dump_set_serial_info_request( const struct set_serial_info_request *req )
1955 {
1956     fprintf( stderr, " handle=%p,", req->handle );
1957     fprintf( stderr, " flags=%d,", req->flags );
1958     fprintf( stderr, " readinterval=%08x,", req->readinterval );
1959     fprintf( stderr, " readconst=%08x,", req->readconst );
1960     fprintf( stderr, " readmult=%08x,", req->readmult );
1961     fprintf( stderr, " writeconst=%08x,", req->writeconst );
1962     fprintf( stderr, " writemult=%08x,", req->writemult );
1963     fprintf( stderr, " eventmask=%08x,", req->eventmask );
1964     fprintf( stderr, " commerror=%08x", req->commerror );
1965 }
1966
1967 static void dump_register_async_request( const struct register_async_request *req )
1968 {
1969     fprintf( stderr, " handle=%p,", req->handle );
1970     fprintf( stderr, " type=%d,", req->type );
1971     fprintf( stderr, " io_apc=%p,", req->io_apc );
1972     fprintf( stderr, " io_sb=%p,", req->io_sb );
1973     fprintf( stderr, " io_user=%p,", req->io_user );
1974     fprintf( stderr, " count=%d", req->count );
1975 }
1976
1977 static void dump_cancel_async_request( const struct cancel_async_request *req )
1978 {
1979     fprintf( stderr, " handle=%p", req->handle );
1980 }
1981
1982 static void dump_create_named_pipe_request( const struct create_named_pipe_request *req )
1983 {
1984     fprintf( stderr, " openmode=%08x,", req->openmode );
1985     fprintf( stderr, " pipemode=%08x,", req->pipemode );
1986     fprintf( stderr, " maxinstances=%08x,", req->maxinstances );
1987     fprintf( stderr, " outsize=%08x,", req->outsize );
1988     fprintf( stderr, " insize=%08x,", req->insize );
1989     fprintf( stderr, " timeout=%08x,", req->timeout );
1990     fprintf( stderr, " inherit=%d,", req->inherit );
1991     fprintf( stderr, " name=" );
1992     dump_varargs_unicode_str( cur_size );
1993 }
1994
1995 static void dump_create_named_pipe_reply( const struct create_named_pipe_reply *req )
1996 {
1997     fprintf( stderr, " handle=%p", req->handle );
1998 }
1999
2000 static void dump_open_named_pipe_request( const struct open_named_pipe_request *req )
2001 {
2002     fprintf( stderr, " access=%08x,", req->access );
2003     fprintf( stderr, " inherit=%d,", req->inherit );
2004     fprintf( stderr, " name=" );
2005     dump_varargs_unicode_str( cur_size );
2006 }
2007
2008 static void dump_open_named_pipe_reply( const struct open_named_pipe_reply *req )
2009 {
2010     fprintf( stderr, " handle=%p", req->handle );
2011 }
2012
2013 static void dump_connect_named_pipe_request( const struct connect_named_pipe_request *req )
2014 {
2015     fprintf( stderr, " handle=%p,", req->handle );
2016     fprintf( stderr, " overlapped=%p,", req->overlapped );
2017     fprintf( stderr, " func=%p", req->func );
2018 }
2019
2020 static void dump_wait_named_pipe_request( const struct wait_named_pipe_request *req )
2021 {
2022     fprintf( stderr, " timeout=%08x,", req->timeout );
2023     fprintf( stderr, " overlapped=%p,", req->overlapped );
2024     fprintf( stderr, " func=%p,", req->func );
2025     fprintf( stderr, " name=" );
2026     dump_varargs_unicode_str( cur_size );
2027 }
2028
2029 static void dump_disconnect_named_pipe_request( const struct disconnect_named_pipe_request *req )
2030 {
2031     fprintf( stderr, " handle=%p", req->handle );
2032 }
2033
2034 static void dump_disconnect_named_pipe_reply( const struct disconnect_named_pipe_reply *req )
2035 {
2036     fprintf( stderr, " fd=%d", req->fd );
2037 }
2038
2039 static void dump_get_named_pipe_info_request( const struct get_named_pipe_info_request *req )
2040 {
2041     fprintf( stderr, " handle=%p", req->handle );
2042 }
2043
2044 static void dump_get_named_pipe_info_reply( const struct get_named_pipe_info_reply *req )
2045 {
2046     fprintf( stderr, " flags=%08x,", req->flags );
2047     fprintf( stderr, " maxinstances=%08x,", req->maxinstances );
2048     fprintf( stderr, " outsize=%08x,", req->outsize );
2049     fprintf( stderr, " insize=%08x", req->insize );
2050 }
2051
2052 static void dump_create_window_request( const struct create_window_request *req )
2053 {
2054     fprintf( stderr, " parent=%p,", req->parent );
2055     fprintf( stderr, " owner=%p,", req->owner );
2056     fprintf( stderr, " atom=%04x,", req->atom );
2057     fprintf( stderr, " instance=%p", req->instance );
2058 }
2059
2060 static void dump_create_window_reply( const struct create_window_reply *req )
2061 {
2062     fprintf( stderr, " handle=%p,", req->handle );
2063     fprintf( stderr, " extra=%d,", req->extra );
2064     fprintf( stderr, " class_ptr=%p", req->class_ptr );
2065 }
2066
2067 static void dump_link_window_request( const struct link_window_request *req )
2068 {
2069     fprintf( stderr, " handle=%p,", req->handle );
2070     fprintf( stderr, " parent=%p,", req->parent );
2071     fprintf( stderr, " previous=%p", req->previous );
2072 }
2073
2074 static void dump_link_window_reply( const struct link_window_reply *req )
2075 {
2076     fprintf( stderr, " full_parent=%p", req->full_parent );
2077 }
2078
2079 static void dump_destroy_window_request( const struct destroy_window_request *req )
2080 {
2081     fprintf( stderr, " handle=%p", req->handle );
2082 }
2083
2084 static void dump_set_window_owner_request( const struct set_window_owner_request *req )
2085 {
2086     fprintf( stderr, " handle=%p,", req->handle );
2087     fprintf( stderr, " owner=%p", req->owner );
2088 }
2089
2090 static void dump_set_window_owner_reply( const struct set_window_owner_reply *req )
2091 {
2092     fprintf( stderr, " full_owner=%p,", req->full_owner );
2093     fprintf( stderr, " prev_owner=%p", req->prev_owner );
2094 }
2095
2096 static void dump_get_window_info_request( const struct get_window_info_request *req )
2097 {
2098     fprintf( stderr, " handle=%p", req->handle );
2099 }
2100
2101 static void dump_get_window_info_reply( const struct get_window_info_reply *req )
2102 {
2103     fprintf( stderr, " full_handle=%p,", req->full_handle );
2104     fprintf( stderr, " last_active=%p,", req->last_active );
2105     fprintf( stderr, " pid=%04x,", req->pid );
2106     fprintf( stderr, " tid=%04x,", req->tid );
2107     fprintf( stderr, " atom=%04x", req->atom );
2108 }
2109
2110 static void dump_set_window_info_request( const struct set_window_info_request *req )
2111 {
2112     fprintf( stderr, " handle=%p,", req->handle );
2113     fprintf( stderr, " flags=%08x,", req->flags );
2114     fprintf( stderr, " style=%08x,", req->style );
2115     fprintf( stderr, " ex_style=%08x,", req->ex_style );
2116     fprintf( stderr, " id=%08x,", req->id );
2117     fprintf( stderr, " instance=%p,", req->instance );
2118     fprintf( stderr, " user_data=%p,", req->user_data );
2119     fprintf( stderr, " extra_offset=%d,", req->extra_offset );
2120     fprintf( stderr, " extra_size=%d,", req->extra_size );
2121     fprintf( stderr, " extra_value=%08x", req->extra_value );
2122 }
2123
2124 static void dump_set_window_info_reply( const struct set_window_info_reply *req )
2125 {
2126     fprintf( stderr, " old_style=%08x,", req->old_style );
2127     fprintf( stderr, " old_ex_style=%08x,", req->old_ex_style );
2128     fprintf( stderr, " old_id=%08x,", req->old_id );
2129     fprintf( stderr, " old_instance=%p,", req->old_instance );
2130     fprintf( stderr, " old_user_data=%p,", req->old_user_data );
2131     fprintf( stderr, " old_extra_value=%08x", req->old_extra_value );
2132 }
2133
2134 static void dump_get_window_parents_request( const struct get_window_parents_request *req )
2135 {
2136     fprintf( stderr, " handle=%p", req->handle );
2137 }
2138
2139 static void dump_get_window_parents_reply( const struct get_window_parents_reply *req )
2140 {
2141     fprintf( stderr, " count=%d,", req->count );
2142     fprintf( stderr, " parents=" );
2143     dump_varargs_user_handles( cur_size );
2144 }
2145
2146 static void dump_get_window_children_request( const struct get_window_children_request *req )
2147 {
2148     fprintf( stderr, " parent=%p,", req->parent );
2149     fprintf( stderr, " atom=%04x,", req->atom );
2150     fprintf( stderr, " tid=%04x", req->tid );
2151 }
2152
2153 static void dump_get_window_children_reply( const struct get_window_children_reply *req )
2154 {
2155     fprintf( stderr, " count=%d,", req->count );
2156     fprintf( stderr, " children=" );
2157     dump_varargs_user_handles( cur_size );
2158 }
2159
2160 static void dump_get_window_children_from_point_request( const struct get_window_children_from_point_request *req )
2161 {
2162     fprintf( stderr, " parent=%p,", req->parent );
2163     fprintf( stderr, " x=%d,", req->x );
2164     fprintf( stderr, " y=%d", req->y );
2165 }
2166
2167 static void dump_get_window_children_from_point_reply( const struct get_window_children_from_point_reply *req )
2168 {
2169     fprintf( stderr, " count=%d,", req->count );
2170     fprintf( stderr, " children=" );
2171     dump_varargs_user_handles( cur_size );
2172 }
2173
2174 static void dump_get_window_tree_request( const struct get_window_tree_request *req )
2175 {
2176     fprintf( stderr, " handle=%p", req->handle );
2177 }
2178
2179 static void dump_get_window_tree_reply( const struct get_window_tree_reply *req )
2180 {
2181     fprintf( stderr, " parent=%p,", req->parent );
2182     fprintf( stderr, " owner=%p,", req->owner );
2183     fprintf( stderr, " next_sibling=%p,", req->next_sibling );
2184     fprintf( stderr, " prev_sibling=%p,", req->prev_sibling );
2185     fprintf( stderr, " first_sibling=%p,", req->first_sibling );
2186     fprintf( stderr, " last_sibling=%p,", req->last_sibling );
2187     fprintf( stderr, " first_child=%p,", req->first_child );
2188     fprintf( stderr, " last_child=%p", req->last_child );
2189 }
2190
2191 static void dump_set_window_pos_request( const struct set_window_pos_request *req )
2192 {
2193     fprintf( stderr, " handle=%p,", req->handle );
2194     fprintf( stderr, " top_win=%p,", req->top_win );
2195     fprintf( stderr, " previous=%p,", req->previous );
2196     fprintf( stderr, " flags=%08x,", req->flags );
2197     fprintf( stderr, " window=" );
2198     dump_rectangle( &req->window );
2199     fprintf( stderr, "," );
2200     fprintf( stderr, " client=" );
2201     dump_rectangle( &req->client );
2202     fprintf( stderr, "," );
2203     fprintf( stderr, " valid=" );
2204     dump_varargs_rectangles( cur_size );
2205 }
2206
2207 static void dump_set_window_pos_reply( const struct set_window_pos_reply *req )
2208 {
2209     fprintf( stderr, " new_style=%08x", req->new_style );
2210 }
2211
2212 static void dump_get_window_rectangles_request( const struct get_window_rectangles_request *req )
2213 {
2214     fprintf( stderr, " handle=%p", req->handle );
2215 }
2216
2217 static void dump_get_window_rectangles_reply( const struct get_window_rectangles_reply *req )
2218 {
2219     fprintf( stderr, " window=" );
2220     dump_rectangle( &req->window );
2221     fprintf( stderr, "," );
2222     fprintf( stderr, " client=" );
2223     dump_rectangle( &req->client );
2224 }
2225
2226 static void dump_get_window_text_request( const struct get_window_text_request *req )
2227 {
2228     fprintf( stderr, " handle=%p", req->handle );
2229 }
2230
2231 static void dump_get_window_text_reply( const struct get_window_text_reply *req )
2232 {
2233     fprintf( stderr, " text=" );
2234     dump_varargs_unicode_str( cur_size );
2235 }
2236
2237 static void dump_set_window_text_request( const struct set_window_text_request *req )
2238 {
2239     fprintf( stderr, " handle=%p,", req->handle );
2240     fprintf( stderr, " text=" );
2241     dump_varargs_unicode_str( cur_size );
2242 }
2243
2244 static void dump_get_windows_offset_request( const struct get_windows_offset_request *req )
2245 {
2246     fprintf( stderr, " from=%p,", req->from );
2247     fprintf( stderr, " to=%p", req->to );
2248 }
2249
2250 static void dump_get_windows_offset_reply( const struct get_windows_offset_reply *req )
2251 {
2252     fprintf( stderr, " x=%d,", req->x );
2253     fprintf( stderr, " y=%d", req->y );
2254 }
2255
2256 static void dump_get_visible_region_request( const struct get_visible_region_request *req )
2257 {
2258     fprintf( stderr, " window=%p,", req->window );
2259     fprintf( stderr, " top_win=%p,", req->top_win );
2260     fprintf( stderr, " flags=%08x", req->flags );
2261 }
2262
2263 static void dump_get_visible_region_reply( const struct get_visible_region_reply *req )
2264 {
2265     fprintf( stderr, " total_size=%d,", req->total_size );
2266     fprintf( stderr, " region=" );
2267     dump_varargs_rectangles( cur_size );
2268 }
2269
2270 static void dump_get_window_region_request( const struct get_window_region_request *req )
2271 {
2272     fprintf( stderr, " window=%p", req->window );
2273 }
2274
2275 static void dump_get_window_region_reply( const struct get_window_region_reply *req )
2276 {
2277     fprintf( stderr, " total_size=%d,", req->total_size );
2278     fprintf( stderr, " region=" );
2279     dump_varargs_rectangles( cur_size );
2280 }
2281
2282 static void dump_set_window_region_request( const struct set_window_region_request *req )
2283 {
2284     fprintf( stderr, " window=%p,", req->window );
2285     fprintf( stderr, " region=" );
2286     dump_varargs_rectangles( cur_size );
2287 }
2288
2289 static void dump_get_update_region_request( const struct get_update_region_request *req )
2290 {
2291     fprintf( stderr, " window=%p,", req->window );
2292     fprintf( stderr, " flags=%08x", req->flags );
2293 }
2294
2295 static void dump_get_update_region_reply( const struct get_update_region_reply *req )
2296 {
2297     fprintf( stderr, " child=%p,", req->child );
2298     fprintf( stderr, " flags=%08x,", req->flags );
2299     fprintf( stderr, " total_size=%d,", req->total_size );
2300     fprintf( stderr, " region=" );
2301     dump_varargs_rectangles( cur_size );
2302 }
2303
2304 static void dump_redraw_window_request( const struct redraw_window_request *req )
2305 {
2306     fprintf( stderr, " window=%p,", req->window );
2307     fprintf( stderr, " flags=%08x,", req->flags );
2308     fprintf( stderr, " region=" );
2309     dump_varargs_rectangles( cur_size );
2310 }
2311
2312 static void dump_set_window_property_request( const struct set_window_property_request *req )
2313 {
2314     fprintf( stderr, " window=%p,", req->window );
2315     fprintf( stderr, " atom=%04x,", req->atom );
2316     fprintf( stderr, " string=%d,", req->string );
2317     fprintf( stderr, " handle=%p", req->handle );
2318 }
2319
2320 static void dump_remove_window_property_request( const struct remove_window_property_request *req )
2321 {
2322     fprintf( stderr, " window=%p,", req->window );
2323     fprintf( stderr, " atom=%04x", req->atom );
2324 }
2325
2326 static void dump_remove_window_property_reply( const struct remove_window_property_reply *req )
2327 {
2328     fprintf( stderr, " handle=%p", req->handle );
2329 }
2330
2331 static void dump_get_window_property_request( const struct get_window_property_request *req )
2332 {
2333     fprintf( stderr, " window=%p,", req->window );
2334     fprintf( stderr, " atom=%04x", req->atom );
2335 }
2336
2337 static void dump_get_window_property_reply( const struct get_window_property_reply *req )
2338 {
2339     fprintf( stderr, " handle=%p", req->handle );
2340 }
2341
2342 static void dump_get_window_properties_request( const struct get_window_properties_request *req )
2343 {
2344     fprintf( stderr, " window=%p", req->window );
2345 }
2346
2347 static void dump_get_window_properties_reply( const struct get_window_properties_reply *req )
2348 {
2349     fprintf( stderr, " total=%d,", req->total );
2350     fprintf( stderr, " props=" );
2351     dump_varargs_properties( cur_size );
2352 }
2353
2354 static void dump_attach_thread_input_request( const struct attach_thread_input_request *req )
2355 {
2356     fprintf( stderr, " tid_from=%04x,", req->tid_from );
2357     fprintf( stderr, " tid_to=%04x,", req->tid_to );
2358     fprintf( stderr, " attach=%d", req->attach );
2359 }
2360
2361 static void dump_get_thread_input_request( const struct get_thread_input_request *req )
2362 {
2363     fprintf( stderr, " tid=%04x", req->tid );
2364 }
2365
2366 static void dump_get_thread_input_reply( const struct get_thread_input_reply *req )
2367 {
2368     fprintf( stderr, " focus=%p,", req->focus );
2369     fprintf( stderr, " capture=%p,", req->capture );
2370     fprintf( stderr, " active=%p,", req->active );
2371     fprintf( stderr, " foreground=%p,", req->foreground );
2372     fprintf( stderr, " menu_owner=%p,", req->menu_owner );
2373     fprintf( stderr, " move_size=%p,", req->move_size );
2374     fprintf( stderr, " caret=%p,", req->caret );
2375     fprintf( stderr, " rect=" );
2376     dump_rectangle( &req->rect );
2377 }
2378
2379 static void dump_get_key_state_request( const struct get_key_state_request *req )
2380 {
2381     fprintf( stderr, " tid=%04x,", req->tid );
2382     fprintf( stderr, " key=%d", req->key );
2383 }
2384
2385 static void dump_get_key_state_reply( const struct get_key_state_reply *req )
2386 {
2387     fprintf( stderr, " state=%02x,", req->state );
2388     fprintf( stderr, " keystate=" );
2389     dump_varargs_bytes( cur_size );
2390 }
2391
2392 static void dump_set_key_state_request( const struct set_key_state_request *req )
2393 {
2394     fprintf( stderr, " tid=%04x,", req->tid );
2395     fprintf( stderr, " keystate=" );
2396     dump_varargs_bytes( cur_size );
2397 }
2398
2399 static void dump_set_foreground_window_request( const struct set_foreground_window_request *req )
2400 {
2401     fprintf( stderr, " handle=%p", req->handle );
2402 }
2403
2404 static void dump_set_foreground_window_reply( const struct set_foreground_window_reply *req )
2405 {
2406     fprintf( stderr, " previous=%p,", req->previous );
2407     fprintf( stderr, " send_msg_old=%d,", req->send_msg_old );
2408     fprintf( stderr, " send_msg_new=%d", req->send_msg_new );
2409 }
2410
2411 static void dump_set_focus_window_request( const struct set_focus_window_request *req )
2412 {
2413     fprintf( stderr, " handle=%p", req->handle );
2414 }
2415
2416 static void dump_set_focus_window_reply( const struct set_focus_window_reply *req )
2417 {
2418     fprintf( stderr, " previous=%p", req->previous );
2419 }
2420
2421 static void dump_set_active_window_request( const struct set_active_window_request *req )
2422 {
2423     fprintf( stderr, " handle=%p", req->handle );
2424 }
2425
2426 static void dump_set_active_window_reply( const struct set_active_window_reply *req )
2427 {
2428     fprintf( stderr, " previous=%p", req->previous );
2429 }
2430
2431 static void dump_set_capture_window_request( const struct set_capture_window_request *req )
2432 {
2433     fprintf( stderr, " handle=%p,", req->handle );
2434     fprintf( stderr, " flags=%08x", req->flags );
2435 }
2436
2437 static void dump_set_capture_window_reply( const struct set_capture_window_reply *req )
2438 {
2439     fprintf( stderr, " previous=%p,", req->previous );
2440     fprintf( stderr, " full_handle=%p", req->full_handle );
2441 }
2442
2443 static void dump_set_caret_window_request( const struct set_caret_window_request *req )
2444 {
2445     fprintf( stderr, " handle=%p,", req->handle );
2446     fprintf( stderr, " width=%d,", req->width );
2447     fprintf( stderr, " height=%d", req->height );
2448 }
2449
2450 static void dump_set_caret_window_reply( const struct set_caret_window_reply *req )
2451 {
2452     fprintf( stderr, " previous=%p,", req->previous );
2453     fprintf( stderr, " old_rect=" );
2454     dump_rectangle( &req->old_rect );
2455     fprintf( stderr, "," );
2456     fprintf( stderr, " old_hide=%d,", req->old_hide );
2457     fprintf( stderr, " old_state=%d", req->old_state );
2458 }
2459
2460 static void dump_set_caret_info_request( const struct set_caret_info_request *req )
2461 {
2462     fprintf( stderr, " flags=%08x,", req->flags );
2463     fprintf( stderr, " handle=%p,", req->handle );
2464     fprintf( stderr, " x=%d,", req->x );
2465     fprintf( stderr, " y=%d,", req->y );
2466     fprintf( stderr, " hide=%d,", req->hide );
2467     fprintf( stderr, " state=%d", req->state );
2468 }
2469
2470 static void dump_set_caret_info_reply( const struct set_caret_info_reply *req )
2471 {
2472     fprintf( stderr, " full_handle=%p,", req->full_handle );
2473     fprintf( stderr, " old_rect=" );
2474     dump_rectangle( &req->old_rect );
2475     fprintf( stderr, "," );
2476     fprintf( stderr, " old_hide=%d,", req->old_hide );
2477     fprintf( stderr, " old_state=%d", req->old_state );
2478 }
2479
2480 static void dump_set_hook_request( const struct set_hook_request *req )
2481 {
2482     fprintf( stderr, " id=%d,", req->id );
2483     fprintf( stderr, " pid=%04x,", req->pid );
2484     fprintf( stderr, " tid=%04x,", req->tid );
2485     fprintf( stderr, " event_min=%d,", req->event_min );
2486     fprintf( stderr, " event_max=%d,", req->event_max );
2487     fprintf( stderr, " flags=%d,", req->flags );
2488     fprintf( stderr, " proc=%p,", req->proc );
2489     fprintf( stderr, " unicode=%d,", req->unicode );
2490     fprintf( stderr, " module=" );
2491     dump_varargs_unicode_str( cur_size );
2492 }
2493
2494 static void dump_set_hook_reply( const struct set_hook_reply *req )
2495 {
2496     fprintf( stderr, " handle=%p", req->handle );
2497 }
2498
2499 static void dump_remove_hook_request( const struct remove_hook_request *req )
2500 {
2501     fprintf( stderr, " handle=%p,", req->handle );
2502     fprintf( stderr, " id=%d,", req->id );
2503     fprintf( stderr, " proc=%p", req->proc );
2504 }
2505
2506 static void dump_start_hook_chain_request( const struct start_hook_chain_request *req )
2507 {
2508     fprintf( stderr, " id=%d,", req->id );
2509     fprintf( stderr, " event=%d,", req->event );
2510     fprintf( stderr, " window=%p,", req->window );
2511     fprintf( stderr, " object_id=%d,", req->object_id );
2512     fprintf( stderr, " child_id=%d", req->child_id );
2513 }
2514
2515 static void dump_start_hook_chain_reply( const struct start_hook_chain_reply *req )
2516 {
2517     fprintf( stderr, " handle=%p,", req->handle );
2518     fprintf( stderr, " pid=%04x,", req->pid );
2519     fprintf( stderr, " tid=%04x,", req->tid );
2520     fprintf( stderr, " proc=%p,", req->proc );
2521     fprintf( stderr, " unicode=%d,", req->unicode );
2522     fprintf( stderr, " module=" );
2523     dump_varargs_unicode_str( cur_size );
2524 }
2525
2526 static void dump_finish_hook_chain_request( const struct finish_hook_chain_request *req )
2527 {
2528     fprintf( stderr, " id=%d", req->id );
2529 }
2530
2531 static void dump_get_next_hook_request( const struct get_next_hook_request *req )
2532 {
2533     fprintf( stderr, " handle=%p,", req->handle );
2534     fprintf( stderr, " event=%d,", req->event );
2535     fprintf( stderr, " window=%p,", req->window );
2536     fprintf( stderr, " object_id=%d,", req->object_id );
2537     fprintf( stderr, " child_id=%d", req->child_id );
2538 }
2539
2540 static void dump_get_next_hook_reply( const struct get_next_hook_reply *req )
2541 {
2542     fprintf( stderr, " next=%p,", req->next );
2543     fprintf( stderr, " id=%d,", req->id );
2544     fprintf( stderr, " pid=%04x,", req->pid );
2545     fprintf( stderr, " tid=%04x,", req->tid );
2546     fprintf( stderr, " proc=%p,", req->proc );
2547     fprintf( stderr, " prev_unicode=%d,", req->prev_unicode );
2548     fprintf( stderr, " next_unicode=%d,", req->next_unicode );
2549     fprintf( stderr, " module=" );
2550     dump_varargs_unicode_str( cur_size );
2551 }
2552
2553 static void dump_create_class_request( const struct create_class_request *req )
2554 {
2555     fprintf( stderr, " local=%d,", req->local );
2556     fprintf( stderr, " atom=%04x,", req->atom );
2557     fprintf( stderr, " style=%08x,", req->style );
2558     fprintf( stderr, " instance=%p,", req->instance );
2559     fprintf( stderr, " extra=%d,", req->extra );
2560     fprintf( stderr, " win_extra=%d,", req->win_extra );
2561     fprintf( stderr, " client_ptr=%p", req->client_ptr );
2562 }
2563
2564 static void dump_destroy_class_request( const struct destroy_class_request *req )
2565 {
2566     fprintf( stderr, " atom=%04x,", req->atom );
2567     fprintf( stderr, " instance=%p", req->instance );
2568 }
2569
2570 static void dump_destroy_class_reply( const struct destroy_class_reply *req )
2571 {
2572     fprintf( stderr, " client_ptr=%p", req->client_ptr );
2573 }
2574
2575 static void dump_set_class_info_request( const struct set_class_info_request *req )
2576 {
2577     fprintf( stderr, " window=%p,", req->window );
2578     fprintf( stderr, " flags=%08x,", req->flags );
2579     fprintf( stderr, " atom=%04x,", req->atom );
2580     fprintf( stderr, " style=%08x,", req->style );
2581     fprintf( stderr, " win_extra=%d,", req->win_extra );
2582     fprintf( stderr, " instance=%p,", req->instance );
2583     fprintf( stderr, " extra_offset=%d,", req->extra_offset );
2584     fprintf( stderr, " extra_size=%d,", req->extra_size );
2585     fprintf( stderr, " extra_value=%08x", req->extra_value );
2586 }
2587
2588 static void dump_set_class_info_reply( const struct set_class_info_reply *req )
2589 {
2590     fprintf( stderr, " old_atom=%04x,", req->old_atom );
2591     fprintf( stderr, " old_style=%08x,", req->old_style );
2592     fprintf( stderr, " old_extra=%d,", req->old_extra );
2593     fprintf( stderr, " old_win_extra=%d,", req->old_win_extra );
2594     fprintf( stderr, " old_instance=%p,", req->old_instance );
2595     fprintf( stderr, " old_extra_value=%08x", req->old_extra_value );
2596 }
2597
2598 static void dump_set_clipboard_info_request( const struct set_clipboard_info_request *req )
2599 {
2600     fprintf( stderr, " flags=%08x,", req->flags );
2601     fprintf( stderr, " clipboard=%p,", req->clipboard );
2602     fprintf( stderr, " owner=%p,", req->owner );
2603     fprintf( stderr, " viewer=%p,", req->viewer );
2604     fprintf( stderr, " seqno=%08x", req->seqno );
2605 }
2606
2607 static void dump_set_clipboard_info_reply( const struct set_clipboard_info_reply *req )
2608 {
2609     fprintf( stderr, " flags=%08x,", req->flags );
2610     fprintf( stderr, " old_clipboard=%p,", req->old_clipboard );
2611     fprintf( stderr, " old_owner=%p,", req->old_owner );
2612     fprintf( stderr, " old_viewer=%p,", req->old_viewer );
2613     fprintf( stderr, " seqno=%08x", req->seqno );
2614 }
2615
2616 static void dump_open_token_request( const struct open_token_request *req )
2617 {
2618     fprintf( stderr, " handle=%p,", req->handle );
2619     fprintf( stderr, " flags=%08x", req->flags );
2620 }
2621
2622 static void dump_open_token_reply( const struct open_token_reply *req )
2623 {
2624     fprintf( stderr, " token=%p", req->token );
2625 }
2626
2627 static void dump_set_global_windows_request( const struct set_global_windows_request *req )
2628 {
2629     fprintf( stderr, " flags=%08x,", req->flags );
2630     fprintf( stderr, " shell_window=%p,", req->shell_window );
2631     fprintf( stderr, " shell_listview=%p,", req->shell_listview );
2632     fprintf( stderr, " progman_window=%p,", req->progman_window );
2633     fprintf( stderr, " taskman_window=%p", req->taskman_window );
2634 }
2635
2636 static void dump_set_global_windows_reply( const struct set_global_windows_reply *req )
2637 {
2638     fprintf( stderr, " old_shell_window=%p,", req->old_shell_window );
2639     fprintf( stderr, " old_shell_listview=%p,", req->old_shell_listview );
2640     fprintf( stderr, " old_progman_window=%p,", req->old_progman_window );
2641     fprintf( stderr, " old_taskman_window=%p", req->old_taskman_window );
2642 }
2643
2644 static void dump_adjust_token_privileges_request( const struct adjust_token_privileges_request *req )
2645 {
2646     fprintf( stderr, " handle=%p,", req->handle );
2647     fprintf( stderr, " disable_all=%d,", req->disable_all );
2648     fprintf( stderr, " get_modified_state=%d,", req->get_modified_state );
2649     fprintf( stderr, " privileges=" );
2650     dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
2651 }
2652
2653 static void dump_adjust_token_privileges_reply( const struct adjust_token_privileges_reply *req )
2654 {
2655     fprintf( stderr, " len=%08x,", req->len );
2656     fprintf( stderr, " privileges=" );
2657     dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
2658 }
2659
2660 static void dump_get_token_privileges_request( const struct get_token_privileges_request *req )
2661 {
2662     fprintf( stderr, " handle=%p", req->handle );
2663 }
2664
2665 static void dump_get_token_privileges_reply( const struct get_token_privileges_reply *req )
2666 {
2667     fprintf( stderr, " len=%08x,", req->len );
2668     fprintf( stderr, " privileges=" );
2669     dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
2670 }
2671
2672 static void dump_duplicate_token_request( const struct duplicate_token_request *req )
2673 {
2674     fprintf( stderr, " handle=%p,", req->handle );
2675     fprintf( stderr, " access=%08x,", req->access );
2676     fprintf( stderr, " inherit=%d,", req->inherit );
2677     fprintf( stderr, " primary=%d,", req->primary );
2678     fprintf( stderr, " impersonation_level=%d", req->impersonation_level );
2679 }
2680
2681 static void dump_duplicate_token_reply( const struct duplicate_token_reply *req )
2682 {
2683     fprintf( stderr, " new_handle=%p", req->new_handle );
2684 }
2685
2686 static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
2687     (dump_func)dump_new_process_request,
2688     (dump_func)dump_get_new_process_info_request,
2689     (dump_func)dump_new_thread_request,
2690     (dump_func)dump_boot_done_request,
2691     (dump_func)dump_init_process_request,
2692     (dump_func)dump_get_startup_info_request,
2693     (dump_func)dump_init_process_done_request,
2694     (dump_func)dump_init_thread_request,
2695     (dump_func)dump_terminate_process_request,
2696     (dump_func)dump_terminate_thread_request,
2697     (dump_func)dump_get_process_info_request,
2698     (dump_func)dump_set_process_info_request,
2699     (dump_func)dump_get_thread_info_request,
2700     (dump_func)dump_set_thread_info_request,
2701     (dump_func)dump_get_dll_info_request,
2702     (dump_func)dump_suspend_thread_request,
2703     (dump_func)dump_resume_thread_request,
2704     (dump_func)dump_load_dll_request,
2705     (dump_func)dump_unload_dll_request,
2706     (dump_func)dump_queue_apc_request,
2707     (dump_func)dump_get_apc_request,
2708     (dump_func)dump_close_handle_request,
2709     (dump_func)dump_set_handle_info_request,
2710     (dump_func)dump_dup_handle_request,
2711     (dump_func)dump_open_process_request,
2712     (dump_func)dump_open_thread_request,
2713     (dump_func)dump_select_request,
2714     (dump_func)dump_create_event_request,
2715     (dump_func)dump_event_op_request,
2716     (dump_func)dump_open_event_request,
2717     (dump_func)dump_create_mutex_request,
2718     (dump_func)dump_release_mutex_request,
2719     (dump_func)dump_open_mutex_request,
2720     (dump_func)dump_create_semaphore_request,
2721     (dump_func)dump_release_semaphore_request,
2722     (dump_func)dump_open_semaphore_request,
2723     (dump_func)dump_create_file_request,
2724     (dump_func)dump_alloc_file_handle_request,
2725     (dump_func)dump_get_handle_fd_request,
2726     (dump_func)dump_flush_file_request,
2727     (dump_func)dump_lock_file_request,
2728     (dump_func)dump_unlock_file_request,
2729     (dump_func)dump_create_socket_request,
2730     (dump_func)dump_accept_socket_request,
2731     (dump_func)dump_set_socket_event_request,
2732     (dump_func)dump_get_socket_event_request,
2733     (dump_func)dump_enable_socket_event_request,
2734     (dump_func)dump_set_socket_deferred_request,
2735     (dump_func)dump_alloc_console_request,
2736     (dump_func)dump_free_console_request,
2737     (dump_func)dump_get_console_renderer_events_request,
2738     (dump_func)dump_open_console_request,
2739     (dump_func)dump_get_console_wait_event_request,
2740     (dump_func)dump_get_console_mode_request,
2741     (dump_func)dump_set_console_mode_request,
2742     (dump_func)dump_set_console_input_info_request,
2743     (dump_func)dump_get_console_input_info_request,
2744     (dump_func)dump_append_console_input_history_request,
2745     (dump_func)dump_get_console_input_history_request,
2746     (dump_func)dump_create_console_output_request,
2747     (dump_func)dump_set_console_output_info_request,
2748     (dump_func)dump_get_console_output_info_request,
2749     (dump_func)dump_write_console_input_request,
2750     (dump_func)dump_read_console_input_request,
2751     (dump_func)dump_write_console_output_request,
2752     (dump_func)dump_fill_console_output_request,
2753     (dump_func)dump_read_console_output_request,
2754     (dump_func)dump_move_console_output_request,
2755     (dump_func)dump_send_console_signal_request,
2756     (dump_func)dump_create_change_notification_request,
2757     (dump_func)dump_next_change_notification_request,
2758     (dump_func)dump_create_mapping_request,
2759     (dump_func)dump_open_mapping_request,
2760     (dump_func)dump_get_mapping_info_request,
2761     (dump_func)dump_create_snapshot_request,
2762     (dump_func)dump_next_process_request,
2763     (dump_func)dump_next_thread_request,
2764     (dump_func)dump_next_module_request,
2765     (dump_func)dump_wait_debug_event_request,
2766     (dump_func)dump_queue_exception_event_request,
2767     (dump_func)dump_get_exception_status_request,
2768     (dump_func)dump_output_debug_string_request,
2769     (dump_func)dump_continue_debug_event_request,
2770     (dump_func)dump_debug_process_request,
2771     (dump_func)dump_debug_break_request,
2772     (dump_func)dump_set_debugger_kill_on_exit_request,
2773     (dump_func)dump_read_process_memory_request,
2774     (dump_func)dump_write_process_memory_request,
2775     (dump_func)dump_create_key_request,
2776     (dump_func)dump_open_key_request,
2777     (dump_func)dump_delete_key_request,
2778     (dump_func)dump_flush_key_request,
2779     (dump_func)dump_enum_key_request,
2780     (dump_func)dump_set_key_value_request,
2781     (dump_func)dump_get_key_value_request,
2782     (dump_func)dump_enum_key_value_request,
2783     (dump_func)dump_delete_key_value_request,
2784     (dump_func)dump_load_registry_request,
2785     (dump_func)dump_unload_registry_request,
2786     (dump_func)dump_save_registry_request,
2787     (dump_func)dump_load_user_registries_request,
2788     (dump_func)dump_set_registry_notification_request,
2789     (dump_func)dump_create_timer_request,
2790     (dump_func)dump_open_timer_request,
2791     (dump_func)dump_set_timer_request,
2792     (dump_func)dump_cancel_timer_request,
2793     (dump_func)dump_get_timer_info_request,
2794     (dump_func)dump_get_thread_context_request,
2795     (dump_func)dump_set_thread_context_request,
2796     (dump_func)dump_get_selector_entry_request,
2797     (dump_func)dump_add_atom_request,
2798     (dump_func)dump_delete_atom_request,
2799     (dump_func)dump_find_atom_request,
2800     (dump_func)dump_get_atom_name_request,
2801     (dump_func)dump_init_atom_table_request,
2802     (dump_func)dump_get_msg_queue_request,
2803     (dump_func)dump_set_queue_mask_request,
2804     (dump_func)dump_get_queue_status_request,
2805     (dump_func)dump_wait_input_idle_request,
2806     (dump_func)dump_send_message_request,
2807     (dump_func)dump_get_message_request,
2808     (dump_func)dump_reply_message_request,
2809     (dump_func)dump_get_message_reply_request,
2810     (dump_func)dump_set_win_timer_request,
2811     (dump_func)dump_kill_win_timer_request,
2812     (dump_func)dump_get_serial_info_request,
2813     (dump_func)dump_set_serial_info_request,
2814     (dump_func)dump_register_async_request,
2815     (dump_func)dump_cancel_async_request,
2816     (dump_func)dump_create_named_pipe_request,
2817     (dump_func)dump_open_named_pipe_request,
2818     (dump_func)dump_connect_named_pipe_request,
2819     (dump_func)dump_wait_named_pipe_request,
2820     (dump_func)dump_disconnect_named_pipe_request,
2821     (dump_func)dump_get_named_pipe_info_request,
2822     (dump_func)dump_create_window_request,
2823     (dump_func)dump_link_window_request,
2824     (dump_func)dump_destroy_window_request,
2825     (dump_func)dump_set_window_owner_request,
2826     (dump_func)dump_get_window_info_request,
2827     (dump_func)dump_set_window_info_request,
2828     (dump_func)dump_get_window_parents_request,
2829     (dump_func)dump_get_window_children_request,
2830     (dump_func)dump_get_window_children_from_point_request,
2831     (dump_func)dump_get_window_tree_request,
2832     (dump_func)dump_set_window_pos_request,
2833     (dump_func)dump_get_window_rectangles_request,
2834     (dump_func)dump_get_window_text_request,
2835     (dump_func)dump_set_window_text_request,
2836     (dump_func)dump_get_windows_offset_request,
2837     (dump_func)dump_get_visible_region_request,
2838     (dump_func)dump_get_window_region_request,
2839     (dump_func)dump_set_window_region_request,
2840     (dump_func)dump_get_update_region_request,
2841     (dump_func)dump_redraw_window_request,
2842     (dump_func)dump_set_window_property_request,
2843     (dump_func)dump_remove_window_property_request,
2844     (dump_func)dump_get_window_property_request,
2845     (dump_func)dump_get_window_properties_request,
2846     (dump_func)dump_attach_thread_input_request,
2847     (dump_func)dump_get_thread_input_request,
2848     (dump_func)dump_get_key_state_request,
2849     (dump_func)dump_set_key_state_request,
2850     (dump_func)dump_set_foreground_window_request,
2851     (dump_func)dump_set_focus_window_request,
2852     (dump_func)dump_set_active_window_request,
2853     (dump_func)dump_set_capture_window_request,
2854     (dump_func)dump_set_caret_window_request,
2855     (dump_func)dump_set_caret_info_request,
2856     (dump_func)dump_set_hook_request,
2857     (dump_func)dump_remove_hook_request,
2858     (dump_func)dump_start_hook_chain_request,
2859     (dump_func)dump_finish_hook_chain_request,
2860     (dump_func)dump_get_next_hook_request,
2861     (dump_func)dump_create_class_request,
2862     (dump_func)dump_destroy_class_request,
2863     (dump_func)dump_set_class_info_request,
2864     (dump_func)dump_set_clipboard_info_request,
2865     (dump_func)dump_open_token_request,
2866     (dump_func)dump_set_global_windows_request,
2867     (dump_func)dump_adjust_token_privileges_request,
2868     (dump_func)dump_get_token_privileges_request,
2869     (dump_func)dump_duplicate_token_request,
2870 };
2871
2872 static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
2873     (dump_func)dump_new_process_reply,
2874     (dump_func)dump_get_new_process_info_reply,
2875     (dump_func)dump_new_thread_reply,
2876     (dump_func)0,
2877     (dump_func)dump_init_process_reply,
2878     (dump_func)dump_get_startup_info_reply,
2879     (dump_func)0,
2880     (dump_func)dump_init_thread_reply,
2881     (dump_func)dump_terminate_process_reply,
2882     (dump_func)dump_terminate_thread_reply,
2883     (dump_func)dump_get_process_info_reply,
2884     (dump_func)0,
2885     (dump_func)dump_get_thread_info_reply,
2886     (dump_func)0,
2887     (dump_func)dump_get_dll_info_reply,
2888     (dump_func)dump_suspend_thread_reply,
2889     (dump_func)dump_resume_thread_reply,
2890     (dump_func)0,
2891     (dump_func)0,
2892     (dump_func)0,
2893     (dump_func)dump_get_apc_reply,
2894     (dump_func)dump_close_handle_reply,
2895     (dump_func)dump_set_handle_info_reply,
2896     (dump_func)dump_dup_handle_reply,
2897     (dump_func)dump_open_process_reply,
2898     (dump_func)dump_open_thread_reply,
2899     (dump_func)0,
2900     (dump_func)dump_create_event_reply,
2901     (dump_func)0,
2902     (dump_func)dump_open_event_reply,
2903     (dump_func)dump_create_mutex_reply,
2904     (dump_func)dump_release_mutex_reply,
2905     (dump_func)dump_open_mutex_reply,
2906     (dump_func)dump_create_semaphore_reply,
2907     (dump_func)dump_release_semaphore_reply,
2908     (dump_func)dump_open_semaphore_reply,
2909     (dump_func)dump_create_file_reply,
2910     (dump_func)dump_alloc_file_handle_reply,
2911     (dump_func)dump_get_handle_fd_reply,
2912     (dump_func)dump_flush_file_reply,
2913     (dump_func)dump_lock_file_reply,
2914     (dump_func)0,
2915     (dump_func)dump_create_socket_reply,
2916     (dump_func)dump_accept_socket_reply,
2917     (dump_func)0,
2918     (dump_func)dump_get_socket_event_reply,
2919     (dump_func)0,
2920     (dump_func)0,
2921     (dump_func)dump_alloc_console_reply,
2922     (dump_func)0,
2923     (dump_func)dump_get_console_renderer_events_reply,
2924     (dump_func)dump_open_console_reply,
2925     (dump_func)dump_get_console_wait_event_reply,
2926     (dump_func)dump_get_console_mode_reply,
2927     (dump_func)0,
2928     (dump_func)0,
2929     (dump_func)dump_get_console_input_info_reply,
2930     (dump_func)0,
2931     (dump_func)dump_get_console_input_history_reply,
2932     (dump_func)dump_create_console_output_reply,
2933     (dump_func)0,
2934     (dump_func)dump_get_console_output_info_reply,
2935     (dump_func)dump_write_console_input_reply,
2936     (dump_func)dump_read_console_input_reply,
2937     (dump_func)dump_write_console_output_reply,
2938     (dump_func)dump_fill_console_output_reply,
2939     (dump_func)dump_read_console_output_reply,
2940     (dump_func)0,
2941     (dump_func)0,
2942     (dump_func)dump_create_change_notification_reply,
2943     (dump_func)0,
2944     (dump_func)dump_create_mapping_reply,
2945     (dump_func)dump_open_mapping_reply,
2946     (dump_func)dump_get_mapping_info_reply,
2947     (dump_func)dump_create_snapshot_reply,
2948     (dump_func)dump_next_process_reply,
2949     (dump_func)dump_next_thread_reply,
2950     (dump_func)dump_next_module_reply,
2951     (dump_func)dump_wait_debug_event_reply,
2952     (dump_func)dump_queue_exception_event_reply,
2953     (dump_func)dump_get_exception_status_reply,
2954     (dump_func)0,
2955     (dump_func)0,
2956     (dump_func)0,
2957     (dump_func)dump_debug_break_reply,
2958     (dump_func)0,
2959     (dump_func)dump_read_process_memory_reply,
2960     (dump_func)0,
2961     (dump_func)dump_create_key_reply,
2962     (dump_func)dump_open_key_reply,
2963     (dump_func)0,
2964     (dump_func)0,
2965     (dump_func)dump_enum_key_reply,
2966     (dump_func)0,
2967     (dump_func)dump_get_key_value_reply,
2968     (dump_func)dump_enum_key_value_reply,
2969     (dump_func)0,
2970     (dump_func)0,
2971     (dump_func)0,
2972     (dump_func)0,
2973     (dump_func)0,
2974     (dump_func)0,
2975     (dump_func)dump_create_timer_reply,
2976     (dump_func)dump_open_timer_reply,
2977     (dump_func)dump_set_timer_reply,
2978     (dump_func)dump_cancel_timer_reply,
2979     (dump_func)dump_get_timer_info_reply,
2980     (dump_func)dump_get_thread_context_reply,
2981     (dump_func)0,
2982     (dump_func)dump_get_selector_entry_reply,
2983     (dump_func)dump_add_atom_reply,
2984     (dump_func)0,
2985     (dump_func)dump_find_atom_reply,
2986     (dump_func)dump_get_atom_name_reply,
2987     (dump_func)0,
2988     (dump_func)dump_get_msg_queue_reply,
2989     (dump_func)dump_set_queue_mask_reply,
2990     (dump_func)dump_get_queue_status_reply,
2991     (dump_func)dump_wait_input_idle_reply,
2992     (dump_func)0,
2993     (dump_func)dump_get_message_reply,
2994     (dump_func)0,
2995     (dump_func)dump_get_message_reply_reply,
2996     (dump_func)dump_set_win_timer_reply,
2997     (dump_func)0,
2998     (dump_func)dump_get_serial_info_reply,
2999     (dump_func)0,
3000     (dump_func)0,
3001     (dump_func)0,
3002     (dump_func)dump_create_named_pipe_reply,
3003     (dump_func)dump_open_named_pipe_reply,
3004     (dump_func)0,
3005     (dump_func)0,
3006     (dump_func)dump_disconnect_named_pipe_reply,
3007     (dump_func)dump_get_named_pipe_info_reply,
3008     (dump_func)dump_create_window_reply,
3009     (dump_func)dump_link_window_reply,
3010     (dump_func)0,
3011     (dump_func)dump_set_window_owner_reply,
3012     (dump_func)dump_get_window_info_reply,
3013     (dump_func)dump_set_window_info_reply,
3014     (dump_func)dump_get_window_parents_reply,
3015     (dump_func)dump_get_window_children_reply,
3016     (dump_func)dump_get_window_children_from_point_reply,
3017     (dump_func)dump_get_window_tree_reply,
3018     (dump_func)dump_set_window_pos_reply,
3019     (dump_func)dump_get_window_rectangles_reply,
3020     (dump_func)dump_get_window_text_reply,
3021     (dump_func)0,
3022     (dump_func)dump_get_windows_offset_reply,
3023     (dump_func)dump_get_visible_region_reply,
3024     (dump_func)dump_get_window_region_reply,
3025     (dump_func)0,
3026     (dump_func)dump_get_update_region_reply,
3027     (dump_func)0,
3028     (dump_func)0,
3029     (dump_func)dump_remove_window_property_reply,
3030     (dump_func)dump_get_window_property_reply,
3031     (dump_func)dump_get_window_properties_reply,
3032     (dump_func)0,
3033     (dump_func)dump_get_thread_input_reply,
3034     (dump_func)dump_get_key_state_reply,
3035     (dump_func)0,
3036     (dump_func)dump_set_foreground_window_reply,
3037     (dump_func)dump_set_focus_window_reply,
3038     (dump_func)dump_set_active_window_reply,
3039     (dump_func)dump_set_capture_window_reply,
3040     (dump_func)dump_set_caret_window_reply,
3041     (dump_func)dump_set_caret_info_reply,
3042     (dump_func)dump_set_hook_reply,
3043     (dump_func)0,
3044     (dump_func)dump_start_hook_chain_reply,
3045     (dump_func)0,
3046     (dump_func)dump_get_next_hook_reply,
3047     (dump_func)0,
3048     (dump_func)dump_destroy_class_reply,
3049     (dump_func)dump_set_class_info_reply,
3050     (dump_func)dump_set_clipboard_info_reply,
3051     (dump_func)dump_open_token_reply,
3052     (dump_func)dump_set_global_windows_reply,
3053     (dump_func)dump_adjust_token_privileges_reply,
3054     (dump_func)dump_get_token_privileges_reply,
3055     (dump_func)dump_duplicate_token_reply,
3056 };
3057
3058 static const char * const req_names[REQ_NB_REQUESTS] = {
3059     "new_process",
3060     "get_new_process_info",
3061     "new_thread",
3062     "boot_done",
3063     "init_process",
3064     "get_startup_info",
3065     "init_process_done",
3066     "init_thread",
3067     "terminate_process",
3068     "terminate_thread",
3069     "get_process_info",
3070     "set_process_info",
3071     "get_thread_info",
3072     "set_thread_info",
3073     "get_dll_info",
3074     "suspend_thread",
3075     "resume_thread",
3076     "load_dll",
3077     "unload_dll",
3078     "queue_apc",
3079     "get_apc",
3080     "close_handle",
3081     "set_handle_info",
3082     "dup_handle",
3083     "open_process",
3084     "open_thread",
3085     "select",
3086     "create_event",
3087     "event_op",
3088     "open_event",
3089     "create_mutex",
3090     "release_mutex",
3091     "open_mutex",
3092     "create_semaphore",
3093     "release_semaphore",
3094     "open_semaphore",
3095     "create_file",
3096     "alloc_file_handle",
3097     "get_handle_fd",
3098     "flush_file",
3099     "lock_file",
3100     "unlock_file",
3101     "create_socket",
3102     "accept_socket",
3103     "set_socket_event",
3104     "get_socket_event",
3105     "enable_socket_event",
3106     "set_socket_deferred",
3107     "alloc_console",
3108     "free_console",
3109     "get_console_renderer_events",
3110     "open_console",
3111     "get_console_wait_event",
3112     "get_console_mode",
3113     "set_console_mode",
3114     "set_console_input_info",
3115     "get_console_input_info",
3116     "append_console_input_history",
3117     "get_console_input_history",
3118     "create_console_output",
3119     "set_console_output_info",
3120     "get_console_output_info",
3121     "write_console_input",
3122     "read_console_input",
3123     "write_console_output",
3124     "fill_console_output",
3125     "read_console_output",
3126     "move_console_output",
3127     "send_console_signal",
3128     "create_change_notification",
3129     "next_change_notification",
3130     "create_mapping",
3131     "open_mapping",
3132     "get_mapping_info",
3133     "create_snapshot",
3134     "next_process",
3135     "next_thread",
3136     "next_module",
3137     "wait_debug_event",
3138     "queue_exception_event",
3139     "get_exception_status",
3140     "output_debug_string",
3141     "continue_debug_event",
3142     "debug_process",
3143     "debug_break",
3144     "set_debugger_kill_on_exit",
3145     "read_process_memory",
3146     "write_process_memory",
3147     "create_key",
3148     "open_key",
3149     "delete_key",
3150     "flush_key",
3151     "enum_key",
3152     "set_key_value",
3153     "get_key_value",
3154     "enum_key_value",
3155     "delete_key_value",
3156     "load_registry",
3157     "unload_registry",
3158     "save_registry",
3159     "load_user_registries",
3160     "set_registry_notification",
3161     "create_timer",
3162     "open_timer",
3163     "set_timer",
3164     "cancel_timer",
3165     "get_timer_info",
3166     "get_thread_context",
3167     "set_thread_context",
3168     "get_selector_entry",
3169     "add_atom",
3170     "delete_atom",
3171     "find_atom",
3172     "get_atom_name",
3173     "init_atom_table",
3174     "get_msg_queue",
3175     "set_queue_mask",
3176     "get_queue_status",
3177     "wait_input_idle",
3178     "send_message",
3179     "get_message",
3180     "reply_message",
3181     "get_message_reply",
3182     "set_win_timer",
3183     "kill_win_timer",
3184     "get_serial_info",
3185     "set_serial_info",
3186     "register_async",
3187     "cancel_async",
3188     "create_named_pipe",
3189     "open_named_pipe",
3190     "connect_named_pipe",
3191     "wait_named_pipe",
3192     "disconnect_named_pipe",
3193     "get_named_pipe_info",
3194     "create_window",
3195     "link_window",
3196     "destroy_window",
3197     "set_window_owner",
3198     "get_window_info",
3199     "set_window_info",
3200     "get_window_parents",
3201     "get_window_children",
3202     "get_window_children_from_point",
3203     "get_window_tree",
3204     "set_window_pos",
3205     "get_window_rectangles",
3206     "get_window_text",
3207     "set_window_text",
3208     "get_windows_offset",
3209     "get_visible_region",
3210     "get_window_region",
3211     "set_window_region",
3212     "get_update_region",
3213     "redraw_window",
3214     "set_window_property",
3215     "remove_window_property",
3216     "get_window_property",
3217     "get_window_properties",
3218     "attach_thread_input",
3219     "get_thread_input",
3220     "get_key_state",
3221     "set_key_state",
3222     "set_foreground_window",
3223     "set_focus_window",
3224     "set_active_window",
3225     "set_capture_window",
3226     "set_caret_window",
3227     "set_caret_info",
3228     "set_hook",
3229     "remove_hook",
3230     "start_hook_chain",
3231     "finish_hook_chain",
3232     "get_next_hook",
3233     "create_class",
3234     "destroy_class",
3235     "set_class_info",
3236     "set_clipboard_info",
3237     "open_token",
3238     "set_global_windows",
3239     "adjust_token_privileges",
3240     "get_token_privileges",
3241     "duplicate_token",
3242 };
3243
3244 /* ### make_requests end ### */
3245 /* Everything above this line is generated automatically by tools/make_requests */
3246
3247 static const char *get_status_name( unsigned int status )
3248 {
3249 #define NAME(status)       { #status, STATUS_##status }
3250 #define NAME_WIN32(error)  { #error, 0xc0010000 | error }
3251     static const struct
3252     {
3253         const char  *name;
3254         unsigned int value;
3255     } status_names[] =
3256     {
3257         NAME(ACCESS_DENIED),
3258         NAME(ACCESS_VIOLATION),
3259         NAME(ALIAS_EXISTS),
3260         NAME(BUFFER_OVERFLOW),
3261         NAME(CHILD_MUST_BE_VOLATILE),
3262         NAME(DIRECTORY_NOT_EMPTY),
3263         NAME(DISK_FULL),
3264         NAME(DLL_NOT_FOUND),
3265         NAME(FILE_IS_A_DIRECTORY),
3266         NAME(FILE_LOCK_CONFLICT),
3267         NAME(INVALID_FILE_FOR_SECTION),
3268         NAME(INVALID_HANDLE),
3269         NAME(INVALID_PARAMETER),
3270         NAME(KEY_DELETED),
3271         NAME(MEDIA_WRITE_PROTECTED),
3272         NAME(MUTANT_NOT_OWNED),
3273         NAME(NOT_A_DIRECTORY),
3274         NAME(NOT_IMPLEMENTED),
3275         NAME(NOT_REGISTRY_FILE),
3276         NAME(NO_DATA_DETECTED),
3277         NAME(NO_MEMORY),
3278         NAME(NO_MORE_ENTRIES),
3279         NAME(NO_MORE_FILES),
3280         NAME(NO_SUCH_FILE),
3281         NAME(OBJECT_NAME_COLLISION),
3282         NAME(OBJECT_NAME_INVALID),
3283         NAME(OBJECT_NAME_NOT_FOUND),
3284         NAME(OBJECT_PATH_INVALID),
3285         NAME(OBJECT_TYPE_MISMATCH),
3286         NAME(PENDING),
3287         NAME(PIPE_BUSY),
3288         NAME(PIPE_CONNECTED),
3289         NAME(PIPE_DISCONNECTED),
3290         NAME(PIPE_LISTENING),
3291         NAME(PIPE_NOT_AVAILABLE),
3292         NAME(SEMAPHORE_LIMIT_EXCEEDED),
3293         NAME(SHARING_VIOLATION),
3294         NAME(SUSPEND_COUNT_EXCEEDED),
3295         NAME(TIMEOUT),
3296         NAME(USER_APC),
3297         NAME(WAS_LOCKED),
3298         NAME_WIN32(ERROR_INVALID_INDEX),
3299         NAME_WIN32(ERROR_INVALID_THREAD_ID),
3300         NAME_WIN32(ERROR_NEGATIVE_SEEK),
3301         NAME_WIN32(ERROR_SEEK),
3302         { NULL, 0 }  /* terminator */
3303     };
3304 #undef NAME
3305
3306     int i;
3307     static char buffer[10];
3308
3309     if (status)
3310     {
3311         for (i = 0; status_names[i].name; i++)
3312             if (status_names[i].value == status) return status_names[i].name;
3313     }
3314     sprintf( buffer, "%x", status );
3315     return buffer;
3316 }
3317
3318 void trace_request(void)
3319 {
3320     enum request req = current->req.request_header.req;
3321     if (req < REQ_NB_REQUESTS)
3322     {
3323         fprintf( stderr, "%04x: %s(", current->id, req_names[req] );
3324         if (req_dumpers[req])
3325         {
3326             cur_pos = 0;
3327             cur_data = get_req_data();
3328             cur_size = get_req_data_size();
3329             req_dumpers[req]( &current->req );
3330         }
3331         fprintf( stderr, " )\n" );
3332     }
3333     else fprintf( stderr, "%04x: %d(?)\n", current->id, req );
3334 }
3335
3336 void trace_reply( enum request req, const union generic_reply *reply )
3337 {
3338     if (req < REQ_NB_REQUESTS)
3339     {
3340         fprintf( stderr, "%04x: %s() = %s",
3341                  current->id, req_names[req], get_status_name(current->error) );
3342         if (reply_dumpers[req])
3343         {
3344             fprintf( stderr, " {" );
3345             cur_pos = 0;
3346             cur_data = current->reply_data;
3347             cur_size = reply->reply_header.reply_size;
3348             reply_dumpers[req]( reply );
3349             fprintf( stderr, " }" );
3350         }
3351         fputc( '\n', stderr );
3352     }
3353     else fprintf( stderr, "%04x: %d() = %s\n",
3354                   current->id, req, get_status_name(current->error) );
3355 }