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

   1 /*
   2  * Server request tracing
   3  *
   4  * Copyright (C) 1999 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 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, " result=%08x,", req->result );
1899     fprintf( stderr, " remove=%d,", req->remove );
1900     fprintf( stderr, " data=" );
1901     dump_varargs_bytes( cur_size );
1902 }
1903
1904 static void dump_accept_hardware_message_request( const struct accept_hardware_message_request *req )
1905 {
1906     fprintf( stderr, " remove=%d,", req->remove );
1907     fprintf( stderr, " new_win=%p", req->new_win );
1908 }
1909
1910 static void dump_get_message_reply_request( const struct get_message_reply_request *req )
1911 {
1912     fprintf( stderr, " cancel=%d", req->cancel );
1913 }
1914
1915 static void dump_get_message_reply_reply( const struct get_message_reply_reply *req )
1916 {
1917     fprintf( stderr, " result=%08x,", req->result );
1918     fprintf( stderr, " data=" );
1919     dump_varargs_bytes( cur_size );
1920 }
1921
1922 static void dump_set_win_timer_request( const struct set_win_timer_request *req )
1923 {
1924     fprintf( stderr, " win=%p,", req->win );
1925     fprintf( stderr, " msg=%08x,", req->msg );
1926     fprintf( stderr, " id=%08x,", req->id );
1927     fprintf( stderr, " rate=%08x,", req->rate );
1928     fprintf( stderr, " lparam=%08x", req->lparam );
1929 }
1930
1931 static void dump_set_win_timer_reply( const struct set_win_timer_reply *req )
1932 {
1933     fprintf( stderr, " id=%08x", req->id );
1934 }
1935
1936 static void dump_kill_win_timer_request( const struct kill_win_timer_request *req )
1937 {
1938     fprintf( stderr, " win=%p,", req->win );
1939     fprintf( stderr, " msg=%08x,", req->msg );
1940     fprintf( stderr, " id=%08x", req->id );
1941 }
1942
1943 static void dump_get_serial_info_request( const struct get_serial_info_request *req )
1944 {
1945     fprintf( stderr, " handle=%p", req->handle );
1946 }
1947
1948 static void dump_get_serial_info_reply( const struct get_serial_info_reply *req )
1949 {
1950     fprintf( stderr, " readinterval=%08x,", req->readinterval );
1951     fprintf( stderr, " readconst=%08x,", req->readconst );
1952     fprintf( stderr, " readmult=%08x,", req->readmult );
1953     fprintf( stderr, " writeconst=%08x,", req->writeconst );
1954     fprintf( stderr, " writemult=%08x,", req->writemult );
1955     fprintf( stderr, " eventmask=%08x,", req->eventmask );
1956     fprintf( stderr, " commerror=%08x", req->commerror );
1957 }
1958
1959 static void dump_set_serial_info_request( const struct set_serial_info_request *req )
1960 {
1961     fprintf( stderr, " handle=%p,", req->handle );
1962     fprintf( stderr, " flags=%d,", req->flags );
1963     fprintf( stderr, " readinterval=%08x,", req->readinterval );
1964     fprintf( stderr, " readconst=%08x,", req->readconst );
1965     fprintf( stderr, " readmult=%08x,", req->readmult );
1966     fprintf( stderr, " writeconst=%08x,", req->writeconst );
1967     fprintf( stderr, " writemult=%08x,", req->writemult );
1968     fprintf( stderr, " eventmask=%08x,", req->eventmask );
1969     fprintf( stderr, " commerror=%08x", req->commerror );
1970 }
1971
1972 static void dump_register_async_request( const struct register_async_request *req )
1973 {
1974     fprintf( stderr, " handle=%p,", req->handle );
1975     fprintf( stderr, " type=%d,", req->type );
1976     fprintf( stderr, " io_apc=%p,", req->io_apc );
1977     fprintf( stderr, " io_sb=%p,", req->io_sb );
1978     fprintf( stderr, " io_user=%p,", req->io_user );
1979     fprintf( stderr, " count=%d", req->count );
1980 }
1981
1982 static void dump_cancel_async_request( const struct cancel_async_request *req )
1983 {
1984     fprintf( stderr, " handle=%p", req->handle );
1985 }
1986
1987 static void dump_create_named_pipe_request( const struct create_named_pipe_request *req )
1988 {
1989     fprintf( stderr, " openmode=%08x,", req->openmode );
1990     fprintf( stderr, " pipemode=%08x,", req->pipemode );
1991     fprintf( stderr, " maxinstances=%08x,", req->maxinstances );
1992     fprintf( stderr, " outsize=%08x,", req->outsize );
1993     fprintf( stderr, " insize=%08x,", req->insize );
1994     fprintf( stderr, " timeout=%08x,", req->timeout );
1995     fprintf( stderr, " inherit=%d,", req->inherit );
1996     fprintf( stderr, " name=" );
1997     dump_varargs_unicode_str( cur_size );
1998 }
1999
2000 static void dump_create_named_pipe_reply( const struct create_named_pipe_reply *req )
2001 {
2002     fprintf( stderr, " handle=%p", req->handle );
2003 }
2004
2005 static void dump_open_named_pipe_request( const struct open_named_pipe_request *req )
2006 {
2007     fprintf( stderr, " access=%08x,", req->access );
2008     fprintf( stderr, " inherit=%d,", req->inherit );
2009     fprintf( stderr, " name=" );
2010     dump_varargs_unicode_str( cur_size );
2011 }
2012
2013 static void dump_open_named_pipe_reply( const struct open_named_pipe_reply *req )
2014 {
2015     fprintf( stderr, " handle=%p", req->handle );
2016 }
2017
2018 static void dump_connect_named_pipe_request( const struct connect_named_pipe_request *req )
2019 {
2020     fprintf( stderr, " handle=%p,", req->handle );
2021     fprintf( stderr, " overlapped=%p,", req->overlapped );
2022     fprintf( stderr, " func=%p", req->func );
2023 }
2024
2025 static void dump_wait_named_pipe_request( const struct wait_named_pipe_request *req )
2026 {
2027     fprintf( stderr, " timeout=%08x,", req->timeout );
2028     fprintf( stderr, " overlapped=%p,", req->overlapped );
2029     fprintf( stderr, " func=%p,", req->func );
2030     fprintf( stderr, " name=" );
2031     dump_varargs_unicode_str( cur_size );
2032 }
2033
2034 static void dump_disconnect_named_pipe_request( const struct disconnect_named_pipe_request *req )
2035 {
2036     fprintf( stderr, " handle=%p", req->handle );
2037 }
2038
2039 static void dump_disconnect_named_pipe_reply( const struct disconnect_named_pipe_reply *req )
2040 {
2041     fprintf( stderr, " fd=%d", req->fd );
2042 }
2043
2044 static void dump_get_named_pipe_info_request( const struct get_named_pipe_info_request *req )
2045 {
2046     fprintf( stderr, " handle=%p", req->handle );
2047 }
2048
2049 static void dump_get_named_pipe_info_reply( const struct get_named_pipe_info_reply *req )
2050 {
2051     fprintf( stderr, " flags=%08x,", req->flags );
2052     fprintf( stderr, " maxinstances=%08x,", req->maxinstances );
2053     fprintf( stderr, " outsize=%08x,", req->outsize );
2054     fprintf( stderr, " insize=%08x", req->insize );
2055 }
2056
2057 static void dump_create_window_request( const struct create_window_request *req )
2058 {
2059     fprintf( stderr, " parent=%p,", req->parent );
2060     fprintf( stderr, " owner=%p,", req->owner );
2061     fprintf( stderr, " atom=%04x,", req->atom );
2062     fprintf( stderr, " instance=%p", req->instance );
2063 }
2064
2065 static void dump_create_window_reply( const struct create_window_reply *req )
2066 {
2067     fprintf( stderr, " handle=%p,", req->handle );
2068     fprintf( stderr, " extra=%d,", req->extra );
2069     fprintf( stderr, " class_ptr=%p", req->class_ptr );
2070 }
2071
2072 static void dump_destroy_window_request( const struct destroy_window_request *req )
2073 {
2074     fprintf( stderr, " handle=%p", req->handle );
2075 }
2076
2077 static void dump_set_window_owner_request( const struct set_window_owner_request *req )
2078 {
2079     fprintf( stderr, " handle=%p,", req->handle );
2080     fprintf( stderr, " owner=%p", req->owner );
2081 }
2082
2083 static void dump_set_window_owner_reply( const struct set_window_owner_reply *req )
2084 {
2085     fprintf( stderr, " full_owner=%p,", req->full_owner );
2086     fprintf( stderr, " prev_owner=%p", req->prev_owner );
2087 }
2088
2089 static void dump_get_window_info_request( const struct get_window_info_request *req )
2090 {
2091     fprintf( stderr, " handle=%p", req->handle );
2092 }
2093
2094 static void dump_get_window_info_reply( const struct get_window_info_reply *req )
2095 {
2096     fprintf( stderr, " full_handle=%p,", req->full_handle );
2097     fprintf( stderr, " last_active=%p,", req->last_active );
2098     fprintf( stderr, " pid=%04x,", req->pid );
2099     fprintf( stderr, " tid=%04x,", req->tid );
2100     fprintf( stderr, " atom=%04x", req->atom );
2101 }
2102
2103 static void dump_set_window_info_request( const struct set_window_info_request *req )
2104 {
2105     fprintf( stderr, " handle=%p,", req->handle );
2106     fprintf( stderr, " flags=%08x,", req->flags );
2107     fprintf( stderr, " style=%08x,", req->style );
2108     fprintf( stderr, " ex_style=%08x,", req->ex_style );
2109     fprintf( stderr, " id=%08x,", req->id );
2110     fprintf( stderr, " instance=%p,", req->instance );
2111     fprintf( stderr, " user_data=%p,", req->user_data );
2112     fprintf( stderr, " extra_offset=%d,", req->extra_offset );
2113     fprintf( stderr, " extra_size=%d,", req->extra_size );
2114     fprintf( stderr, " extra_value=%08x", req->extra_value );
2115 }
2116
2117 static void dump_set_window_info_reply( const struct set_window_info_reply *req )
2118 {
2119     fprintf( stderr, " old_style=%08x,", req->old_style );
2120     fprintf( stderr, " old_ex_style=%08x,", req->old_ex_style );
2121     fprintf( stderr, " old_id=%08x,", req->old_id );
2122     fprintf( stderr, " old_instance=%p,", req->old_instance );
2123     fprintf( stderr, " old_user_data=%p,", req->old_user_data );
2124     fprintf( stderr, " old_extra_value=%08x", req->old_extra_value );
2125 }
2126
2127 static void dump_set_parent_request( const struct set_parent_request *req )
2128 {
2129     fprintf( stderr, " handle=%p,", req->handle );
2130     fprintf( stderr, " parent=%p", req->parent );
2131 }
2132
2133 static void dump_set_parent_reply( const struct set_parent_reply *req )
2134 {
2135     fprintf( stderr, " old_parent=%p,", req->old_parent );
2136     fprintf( stderr, " full_parent=%p", req->full_parent );
2137 }
2138
2139 static void dump_get_window_parents_request( const struct get_window_parents_request *req )
2140 {
2141     fprintf( stderr, " handle=%p", req->handle );
2142 }
2143
2144 static void dump_get_window_parents_reply( const struct get_window_parents_reply *req )
2145 {
2146     fprintf( stderr, " count=%d,", req->count );
2147     fprintf( stderr, " parents=" );
2148     dump_varargs_user_handles( cur_size );
2149 }
2150
2151 static void dump_get_window_children_request( const struct get_window_children_request *req )
2152 {
2153     fprintf( stderr, " parent=%p,", req->parent );
2154     fprintf( stderr, " atom=%04x,", req->atom );
2155     fprintf( stderr, " tid=%04x", req->tid );
2156 }
2157
2158 static void dump_get_window_children_reply( const struct get_window_children_reply *req )
2159 {
2160     fprintf( stderr, " count=%d,", req->count );
2161     fprintf( stderr, " children=" );
2162     dump_varargs_user_handles( cur_size );
2163 }
2164
2165 static void dump_get_window_children_from_point_request( const struct get_window_children_from_point_request *req )
2166 {
2167     fprintf( stderr, " parent=%p,", req->parent );
2168     fprintf( stderr, " x=%d,", req->x );
2169     fprintf( stderr, " y=%d", req->y );
2170 }
2171
2172 static void dump_get_window_children_from_point_reply( const struct get_window_children_from_point_reply *req )
2173 {
2174     fprintf( stderr, " count=%d,", req->count );
2175     fprintf( stderr, " children=" );
2176     dump_varargs_user_handles( cur_size );
2177 }
2178
2179 static void dump_get_window_tree_request( const struct get_window_tree_request *req )
2180 {
2181     fprintf( stderr, " handle=%p", req->handle );
2182 }
2183
2184 static void dump_get_window_tree_reply( const struct get_window_tree_reply *req )
2185 {
2186     fprintf( stderr, " parent=%p,", req->parent );
2187     fprintf( stderr, " owner=%p,", req->owner );
2188     fprintf( stderr, " next_sibling=%p,", req->next_sibling );
2189     fprintf( stderr, " prev_sibling=%p,", req->prev_sibling );
2190     fprintf( stderr, " first_sibling=%p,", req->first_sibling );
2191     fprintf( stderr, " last_sibling=%p,", req->last_sibling );
2192     fprintf( stderr, " first_child=%p,", req->first_child );
2193     fprintf( stderr, " last_child=%p", req->last_child );
2194 }
2195
2196 static void dump_set_window_pos_request( const struct set_window_pos_request *req )
2197 {
2198     fprintf( stderr, " handle=%p,", req->handle );
2199     fprintf( stderr, " previous=%p,", req->previous );
2200     fprintf( stderr, " flags=%08x,", req->flags );
2201     fprintf( stderr, " window=" );
2202     dump_rectangle( &req->window );
2203     fprintf( stderr, "," );
2204     fprintf( stderr, " client=" );
2205     dump_rectangle( &req->client );
2206     fprintf( stderr, "," );
2207     fprintf( stderr, " valid=" );
2208     dump_varargs_rectangles( cur_size );
2209 }
2210
2211 static void dump_set_window_pos_reply( const struct set_window_pos_reply *req )
2212 {
2213     fprintf( stderr, " new_style=%08x", req->new_style );
2214 }
2215
2216 static void dump_get_window_rectangles_request( const struct get_window_rectangles_request *req )
2217 {
2218     fprintf( stderr, " handle=%p", req->handle );
2219 }
2220
2221 static void dump_get_window_rectangles_reply( const struct get_window_rectangles_reply *req )
2222 {
2223     fprintf( stderr, " window=" );
2224     dump_rectangle( &req->window );
2225     fprintf( stderr, "," );
2226     fprintf( stderr, " visible=" );
2227     dump_rectangle( &req->visible );
2228     fprintf( stderr, "," );
2229     fprintf( stderr, " client=" );
2230     dump_rectangle( &req->client );
2231 }
2232
2233 static void dump_get_window_text_request( const struct get_window_text_request *req )
2234 {
2235     fprintf( stderr, " handle=%p", req->handle );
2236 }
2237
2238 static void dump_get_window_text_reply( const struct get_window_text_reply *req )
2239 {
2240     fprintf( stderr, " text=" );
2241     dump_varargs_unicode_str( cur_size );
2242 }
2243
2244 static void dump_set_window_text_request( const struct set_window_text_request *req )
2245 {
2246     fprintf( stderr, " handle=%p,", req->handle );
2247     fprintf( stderr, " text=" );
2248     dump_varargs_unicode_str( cur_size );
2249 }
2250
2251 static void dump_get_windows_offset_request( const struct get_windows_offset_request *req )
2252 {
2253     fprintf( stderr, " from=%p,", req->from );
2254     fprintf( stderr, " to=%p", req->to );
2255 }
2256
2257 static void dump_get_windows_offset_reply( const struct get_windows_offset_reply *req )
2258 {
2259     fprintf( stderr, " x=%d,", req->x );
2260     fprintf( stderr, " y=%d", req->y );
2261 }
2262
2263 static void dump_get_visible_region_request( const struct get_visible_region_request *req )
2264 {
2265     fprintf( stderr, " window=%p,", req->window );
2266     fprintf( stderr, " flags=%08x", req->flags );
2267 }
2268
2269 static void dump_get_visible_region_reply( const struct get_visible_region_reply *req )
2270 {
2271     fprintf( stderr, " top_win=%p,", req->top_win );
2272     fprintf( stderr, " top_org_x=%d,", req->top_org_x );
2273     fprintf( stderr, " top_org_y=%d,", req->top_org_y );
2274     fprintf( stderr, " win_org_x=%d,", req->win_org_x );
2275     fprintf( stderr, " win_org_y=%d,", req->win_org_y );
2276     fprintf( stderr, " total_size=%d,", req->total_size );
2277     fprintf( stderr, " region=" );
2278     dump_varargs_rectangles( cur_size );
2279 }
2280
2281 static void dump_get_window_region_request( const struct get_window_region_request *req )
2282 {
2283     fprintf( stderr, " window=%p", req->window );
2284 }
2285
2286 static void dump_get_window_region_reply( const struct get_window_region_reply *req )
2287 {
2288     fprintf( stderr, " total_size=%d,", req->total_size );
2289     fprintf( stderr, " region=" );
2290     dump_varargs_rectangles( cur_size );
2291 }
2292
2293 static void dump_set_window_region_request( const struct set_window_region_request *req )
2294 {
2295     fprintf( stderr, " window=%p,", req->window );
2296     fprintf( stderr, " region=" );
2297     dump_varargs_rectangles( cur_size );
2298 }
2299
2300 static void dump_get_update_region_request( const struct get_update_region_request *req )
2301 {
2302     fprintf( stderr, " window=%p,", req->window );
2303     fprintf( stderr, " flags=%08x", req->flags );
2304 }
2305
2306 static void dump_get_update_region_reply( const struct get_update_region_reply *req )
2307 {
2308     fprintf( stderr, " child=%p,", req->child );
2309     fprintf( stderr, " flags=%08x,", req->flags );
2310     fprintf( stderr, " total_size=%d,", req->total_size );
2311     fprintf( stderr, " region=" );
2312     dump_varargs_rectangles( cur_size );
2313 }
2314
2315 static void dump_update_window_zorder_request( const struct update_window_zorder_request *req )
2316 {
2317     fprintf( stderr, " window=%p,", req->window );
2318     fprintf( stderr, " rect=" );
2319     dump_rectangle( &req->rect );
2320 }
2321
2322 static void dump_redraw_window_request( const struct redraw_window_request *req )
2323 {
2324     fprintf( stderr, " window=%p,", req->window );
2325     fprintf( stderr, " flags=%08x,", req->flags );
2326     fprintf( stderr, " region=" );
2327     dump_varargs_rectangles( cur_size );
2328 }
2329
2330 static void dump_set_window_property_request( const struct set_window_property_request *req )
2331 {
2332     fprintf( stderr, " window=%p,", req->window );
2333     fprintf( stderr, " atom=%04x,", req->atom );
2334     fprintf( stderr, " string=%d,", req->string );
2335     fprintf( stderr, " handle=%p", req->handle );
2336 }
2337
2338 static void dump_remove_window_property_request( const struct remove_window_property_request *req )
2339 {
2340     fprintf( stderr, " window=%p,", req->window );
2341     fprintf( stderr, " atom=%04x", req->atom );
2342 }
2343
2344 static void dump_remove_window_property_reply( const struct remove_window_property_reply *req )
2345 {
2346     fprintf( stderr, " handle=%p", req->handle );
2347 }
2348
2349 static void dump_get_window_property_request( const struct get_window_property_request *req )
2350 {
2351     fprintf( stderr, " window=%p,", req->window );
2352     fprintf( stderr, " atom=%04x", req->atom );
2353 }
2354
2355 static void dump_get_window_property_reply( const struct get_window_property_reply *req )
2356 {
2357     fprintf( stderr, " handle=%p", req->handle );
2358 }
2359
2360 static void dump_get_window_properties_request( const struct get_window_properties_request *req )
2361 {
2362     fprintf( stderr, " window=%p", req->window );
2363 }
2364
2365 static void dump_get_window_properties_reply( const struct get_window_properties_reply *req )
2366 {
2367     fprintf( stderr, " total=%d,", req->total );
2368     fprintf( stderr, " props=" );
2369     dump_varargs_properties( cur_size );
2370 }
2371
2372 static void dump_attach_thread_input_request( const struct attach_thread_input_request *req )
2373 {
2374     fprintf( stderr, " tid_from=%04x,", req->tid_from );
2375     fprintf( stderr, " tid_to=%04x,", req->tid_to );
2376     fprintf( stderr, " attach=%d", req->attach );
2377 }
2378
2379 static void dump_get_thread_input_request( const struct get_thread_input_request *req )
2380 {
2381     fprintf( stderr, " tid=%04x", req->tid );
2382 }
2383
2384 static void dump_get_thread_input_reply( const struct get_thread_input_reply *req )
2385 {
2386     fprintf( stderr, " focus=%p,", req->focus );
2387     fprintf( stderr, " capture=%p,", req->capture );
2388     fprintf( stderr, " active=%p,", req->active );
2389     fprintf( stderr, " foreground=%p,", req->foreground );
2390     fprintf( stderr, " menu_owner=%p,", req->menu_owner );
2391     fprintf( stderr, " move_size=%p,", req->move_size );
2392     fprintf( stderr, " caret=%p,", req->caret );
2393     fprintf( stderr, " rect=" );
2394     dump_rectangle( &req->rect );
2395 }
2396
2397 static void dump_get_key_state_request( const struct get_key_state_request *req )
2398 {
2399     fprintf( stderr, " tid=%04x,", req->tid );
2400     fprintf( stderr, " key=%d", req->key );
2401 }
2402
2403 static void dump_get_key_state_reply( const struct get_key_state_reply *req )
2404 {
2405     fprintf( stderr, " state=%02x,", req->state );
2406     fprintf( stderr, " keystate=" );
2407     dump_varargs_bytes( cur_size );
2408 }
2409
2410 static void dump_set_key_state_request( const struct set_key_state_request *req )
2411 {
2412     fprintf( stderr, " tid=%04x,", req->tid );
2413     fprintf( stderr, " keystate=" );
2414     dump_varargs_bytes( cur_size );
2415 }
2416
2417 static void dump_set_foreground_window_request( const struct set_foreground_window_request *req )
2418 {
2419     fprintf( stderr, " handle=%p", req->handle );
2420 }
2421
2422 static void dump_set_foreground_window_reply( const struct set_foreground_window_reply *req )
2423 {
2424     fprintf( stderr, " previous=%p,", req->previous );
2425     fprintf( stderr, " send_msg_old=%d,", req->send_msg_old );
2426     fprintf( stderr, " send_msg_new=%d", req->send_msg_new );
2427 }
2428
2429 static void dump_set_focus_window_request( const struct set_focus_window_request *req )
2430 {
2431     fprintf( stderr, " handle=%p", req->handle );
2432 }
2433
2434 static void dump_set_focus_window_reply( const struct set_focus_window_reply *req )
2435 {
2436     fprintf( stderr, " previous=%p", req->previous );
2437 }
2438
2439 static void dump_set_active_window_request( const struct set_active_window_request *req )
2440 {
2441     fprintf( stderr, " handle=%p", req->handle );
2442 }
2443
2444 static void dump_set_active_window_reply( const struct set_active_window_reply *req )
2445 {
2446     fprintf( stderr, " previous=%p", req->previous );
2447 }
2448
2449 static void dump_set_capture_window_request( const struct set_capture_window_request *req )
2450 {
2451     fprintf( stderr, " handle=%p,", req->handle );
2452     fprintf( stderr, " flags=%08x", req->flags );
2453 }
2454
2455 static void dump_set_capture_window_reply( const struct set_capture_window_reply *req )
2456 {
2457     fprintf( stderr, " previous=%p,", req->previous );
2458     fprintf( stderr, " full_handle=%p", req->full_handle );
2459 }
2460
2461 static void dump_set_caret_window_request( const struct set_caret_window_request *req )
2462 {
2463     fprintf( stderr, " handle=%p,", req->handle );
2464     fprintf( stderr, " width=%d,", req->width );
2465     fprintf( stderr, " height=%d", req->height );
2466 }
2467
2468 static void dump_set_caret_window_reply( const struct set_caret_window_reply *req )
2469 {
2470     fprintf( stderr, " previous=%p,", req->previous );
2471     fprintf( stderr, " old_rect=" );
2472     dump_rectangle( &req->old_rect );
2473     fprintf( stderr, "," );
2474     fprintf( stderr, " old_hide=%d,", req->old_hide );
2475     fprintf( stderr, " old_state=%d", req->old_state );
2476 }
2477
2478 static void dump_set_caret_info_request( const struct set_caret_info_request *req )
2479 {
2480     fprintf( stderr, " flags=%08x,", req->flags );
2481     fprintf( stderr, " handle=%p,", req->handle );
2482     fprintf( stderr, " x=%d,", req->x );
2483     fprintf( stderr, " y=%d,", req->y );
2484     fprintf( stderr, " hide=%d,", req->hide );
2485     fprintf( stderr, " state=%d", req->state );
2486 }
2487
2488 static void dump_set_caret_info_reply( const struct set_caret_info_reply *req )
2489 {
2490     fprintf( stderr, " full_handle=%p,", req->full_handle );
2491     fprintf( stderr, " old_rect=" );
2492     dump_rectangle( &req->old_rect );
2493     fprintf( stderr, "," );
2494     fprintf( stderr, " old_hide=%d,", req->old_hide );
2495     fprintf( stderr, " old_state=%d", req->old_state );
2496 }
2497
2498 static void dump_set_hook_request( const struct set_hook_request *req )
2499 {
2500     fprintf( stderr, " id=%d,", req->id );
2501     fprintf( stderr, " pid=%04x,", req->pid );
2502     fprintf( stderr, " tid=%04x,", req->tid );
2503     fprintf( stderr, " event_min=%d,", req->event_min );
2504     fprintf( stderr, " event_max=%d,", req->event_max );
2505     fprintf( stderr, " flags=%d,", req->flags );
2506     fprintf( stderr, " proc=%p,", req->proc );
2507     fprintf( stderr, " unicode=%d,", req->unicode );
2508     fprintf( stderr, " module=" );
2509     dump_varargs_unicode_str( cur_size );
2510 }
2511
2512 static void dump_set_hook_reply( const struct set_hook_reply *req )
2513 {
2514     fprintf( stderr, " handle=%p", req->handle );
2515 }
2516
2517 static void dump_remove_hook_request( const struct remove_hook_request *req )
2518 {
2519     fprintf( stderr, " handle=%p,", req->handle );
2520     fprintf( stderr, " id=%d,", req->id );
2521     fprintf( stderr, " proc=%p", req->proc );
2522 }
2523
2524 static void dump_start_hook_chain_request( const struct start_hook_chain_request *req )
2525 {
2526     fprintf( stderr, " id=%d,", req->id );
2527     fprintf( stderr, " event=%d,", req->event );
2528     fprintf( stderr, " window=%p,", req->window );
2529     fprintf( stderr, " object_id=%d,", req->object_id );
2530     fprintf( stderr, " child_id=%d", req->child_id );
2531 }
2532
2533 static void dump_start_hook_chain_reply( const struct start_hook_chain_reply *req )
2534 {
2535     fprintf( stderr, " handle=%p,", req->handle );
2536     fprintf( stderr, " pid=%04x,", req->pid );
2537     fprintf( stderr, " tid=%04x,", req->tid );
2538     fprintf( stderr, " proc=%p,", req->proc );
2539     fprintf( stderr, " unicode=%d,", req->unicode );
2540     fprintf( stderr, " module=" );
2541     dump_varargs_unicode_str( cur_size );
2542 }
2543
2544 static void dump_finish_hook_chain_request( const struct finish_hook_chain_request *req )
2545 {
2546     fprintf( stderr, " id=%d", req->id );
2547 }
2548
2549 static void dump_get_next_hook_request( const struct get_next_hook_request *req )
2550 {
2551     fprintf( stderr, " handle=%p,", req->handle );
2552     fprintf( stderr, " event=%d,", req->event );
2553     fprintf( stderr, " window=%p,", req->window );
2554     fprintf( stderr, " object_id=%d,", req->object_id );
2555     fprintf( stderr, " child_id=%d", req->child_id );
2556 }
2557
2558 static void dump_get_next_hook_reply( const struct get_next_hook_reply *req )
2559 {
2560     fprintf( stderr, " next=%p,", req->next );
2561     fprintf( stderr, " id=%d,", req->id );
2562     fprintf( stderr, " pid=%04x,", req->pid );
2563     fprintf( stderr, " tid=%04x,", req->tid );
2564     fprintf( stderr, " proc=%p,", req->proc );
2565     fprintf( stderr, " prev_unicode=%d,", req->prev_unicode );
2566     fprintf( stderr, " next_unicode=%d,", req->next_unicode );
2567     fprintf( stderr, " module=" );
2568     dump_varargs_unicode_str( cur_size );
2569 }
2570
2571 static void dump_create_class_request( const struct create_class_request *req )
2572 {
2573     fprintf( stderr, " local=%d,", req->local );
2574     fprintf( stderr, " atom=%04x,", req->atom );
2575     fprintf( stderr, " style=%08x,", req->style );
2576     fprintf( stderr, " instance=%p,", req->instance );
2577     fprintf( stderr, " extra=%d,", req->extra );
2578     fprintf( stderr, " win_extra=%d,", req->win_extra );
2579     fprintf( stderr, " client_ptr=%p", req->client_ptr );
2580 }
2581
2582 static void dump_destroy_class_request( const struct destroy_class_request *req )
2583 {
2584     fprintf( stderr, " atom=%04x,", req->atom );
2585     fprintf( stderr, " instance=%p", req->instance );
2586 }
2587
2588 static void dump_destroy_class_reply( const struct destroy_class_reply *req )
2589 {
2590     fprintf( stderr, " client_ptr=%p", req->client_ptr );
2591 }
2592
2593 static void dump_set_class_info_request( const struct set_class_info_request *req )
2594 {
2595     fprintf( stderr, " window=%p,", req->window );
2596     fprintf( stderr, " flags=%08x,", req->flags );
2597     fprintf( stderr, " atom=%04x,", req->atom );
2598     fprintf( stderr, " style=%08x,", req->style );
2599     fprintf( stderr, " win_extra=%d,", req->win_extra );
2600     fprintf( stderr, " instance=%p,", req->instance );
2601     fprintf( stderr, " extra_offset=%d,", req->extra_offset );
2602     fprintf( stderr, " extra_size=%d,", req->extra_size );
2603     fprintf( stderr, " extra_value=%08x", req->extra_value );
2604 }
2605
2606 static void dump_set_class_info_reply( const struct set_class_info_reply *req )
2607 {
2608     fprintf( stderr, " old_atom=%04x,", req->old_atom );
2609     fprintf( stderr, " old_style=%08x,", req->old_style );
2610     fprintf( stderr, " old_extra=%d,", req->old_extra );
2611     fprintf( stderr, " old_win_extra=%d,", req->old_win_extra );
2612     fprintf( stderr, " old_instance=%p,", req->old_instance );
2613     fprintf( stderr, " old_extra_value=%08x", req->old_extra_value );
2614 }
2615
2616 static void dump_set_clipboard_info_request( const struct set_clipboard_info_request *req )
2617 {
2618     fprintf( stderr, " flags=%08x,", req->flags );
2619     fprintf( stderr, " clipboard=%p,", req->clipboard );
2620     fprintf( stderr, " owner=%p,", req->owner );
2621     fprintf( stderr, " viewer=%p,", req->viewer );
2622     fprintf( stderr, " seqno=%08x", req->seqno );
2623 }
2624
2625 static void dump_set_clipboard_info_reply( const struct set_clipboard_info_reply *req )
2626 {
2627     fprintf( stderr, " flags=%08x,", req->flags );
2628     fprintf( stderr, " old_clipboard=%p,", req->old_clipboard );
2629     fprintf( stderr, " old_owner=%p,", req->old_owner );
2630     fprintf( stderr, " old_viewer=%p,", req->old_viewer );
2631     fprintf( stderr, " seqno=%08x", req->seqno );
2632 }
2633
2634 static void dump_open_token_request( const struct open_token_request *req )
2635 {
2636     fprintf( stderr, " handle=%p,", req->handle );
2637     fprintf( stderr, " flags=%08x", req->flags );
2638 }
2639
2640 static void dump_open_token_reply( const struct open_token_reply *req )
2641 {
2642     fprintf( stderr, " token=%p", req->token );
2643 }
2644
2645 static void dump_set_global_windows_request( const struct set_global_windows_request *req )
2646 {
2647     fprintf( stderr, " flags=%08x,", req->flags );
2648     fprintf( stderr, " shell_window=%p,", req->shell_window );
2649     fprintf( stderr, " shell_listview=%p,", req->shell_listview );
2650     fprintf( stderr, " progman_window=%p,", req->progman_window );
2651     fprintf( stderr, " taskman_window=%p", req->taskman_window );
2652 }
2653
2654 static void dump_set_global_windows_reply( const struct set_global_windows_reply *req )
2655 {
2656     fprintf( stderr, " old_shell_window=%p,", req->old_shell_window );
2657     fprintf( stderr, " old_shell_listview=%p,", req->old_shell_listview );
2658     fprintf( stderr, " old_progman_window=%p,", req->old_progman_window );
2659     fprintf( stderr, " old_taskman_window=%p", req->old_taskman_window );
2660 }
2661
2662 static void dump_adjust_token_privileges_request( const struct adjust_token_privileges_request *req )
2663 {
2664     fprintf( stderr, " handle=%p,", req->handle );
2665     fprintf( stderr, " disable_all=%d,", req->disable_all );
2666     fprintf( stderr, " get_modified_state=%d,", req->get_modified_state );
2667     fprintf( stderr, " privileges=" );
2668     dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
2669 }
2670
2671 static void dump_adjust_token_privileges_reply( const struct adjust_token_privileges_reply *req )
2672 {
2673     fprintf( stderr, " len=%08x,", req->len );
2674     fprintf( stderr, " privileges=" );
2675     dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
2676 }
2677
2678 static void dump_get_token_privileges_request( const struct get_token_privileges_request *req )
2679 {
2680     fprintf( stderr, " handle=%p", req->handle );
2681 }
2682
2683 static void dump_get_token_privileges_reply( const struct get_token_privileges_reply *req )
2684 {
2685     fprintf( stderr, " len=%08x,", req->len );
2686     fprintf( stderr, " privileges=" );
2687     dump_varargs_LUID_AND_ATTRIBUTES( cur_size );
2688 }
2689
2690 static void dump_duplicate_token_request( const struct duplicate_token_request *req )
2691 {
2692     fprintf( stderr, " handle=%p,", req->handle );
2693     fprintf( stderr, " access=%08x,", req->access );
2694     fprintf( stderr, " inherit=%d,", req->inherit );
2695     fprintf( stderr, " primary=%d,", req->primary );
2696     fprintf( stderr, " impersonation_level=%d", req->impersonation_level );
2697 }
2698
2699 static void dump_duplicate_token_reply( const struct duplicate_token_reply *req )
2700 {
2701     fprintf( stderr, " new_handle=%p", req->new_handle );
2702 }
2703
2704 static void dump_create_mailslot_request( const struct create_mailslot_request *req )
2705 {
2706     fprintf( stderr, " max_msgsize=%08x,", req->max_msgsize );
2707     fprintf( stderr, " read_timeout=%08x,", req->read_timeout );
2708     fprintf( stderr, " inherit=%d,", req->inherit );
2709     fprintf( stderr, " name=" );
2710     dump_varargs_unicode_str( cur_size );
2711 }
2712
2713 static void dump_create_mailslot_reply( const struct create_mailslot_reply *req )
2714 {
2715     fprintf( stderr, " handle=%p", req->handle );
2716 }
2717
2718 static void dump_open_mailslot_request( const struct open_mailslot_request *req )
2719 {
2720     fprintf( stderr, " access=%08x,", req->access );
2721     fprintf( stderr, " inherit=%d,", req->inherit );
2722     fprintf( stderr, " sharing=%08x,", req->sharing );
2723     fprintf( stderr, " name=" );
2724     dump_varargs_unicode_str( cur_size );
2725 }
2726
2727 static void dump_open_mailslot_reply( const struct open_mailslot_reply *req )
2728 {
2729     fprintf( stderr, " handle=%p", req->handle );
2730 }
2731
2732 static void dump_set_mailslot_info_request( const struct set_mailslot_info_request *req )
2733 {
2734     fprintf( stderr, " handle=%p,", req->handle );
2735     fprintf( stderr, " flags=%08x,", req->flags );
2736     fprintf( stderr, " read_timeout=%08x", req->read_timeout );
2737 }
2738
2739 static void dump_set_mailslot_info_reply( const struct set_mailslot_info_reply *req )
2740 {
2741     fprintf( stderr, " max_msgsize=%08x,", req->max_msgsize );
2742     fprintf( stderr, " read_timeout=%08x,", req->read_timeout );
2743     fprintf( stderr, " msg_count=%08x,", req->msg_count );
2744     fprintf( stderr, " next_msgsize=%08x", req->next_msgsize );
2745 }
2746
2747 static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
2748     (dump_func)dump_new_process_request,
2749     (dump_func)dump_get_new_process_info_request,
2750     (dump_func)dump_new_thread_request,
2751     (dump_func)dump_boot_done_request,
2752     (dump_func)dump_init_process_request,
2753     (dump_func)dump_get_startup_info_request,
2754     (dump_func)dump_init_process_done_request,
2755     (dump_func)dump_init_thread_request,
2756     (dump_func)dump_terminate_process_request,
2757     (dump_func)dump_terminate_thread_request,
2758     (dump_func)dump_get_process_info_request,
2759     (dump_func)dump_set_process_info_request,
2760     (dump_func)dump_get_thread_info_request,
2761     (dump_func)dump_set_thread_info_request,
2762     (dump_func)dump_get_dll_info_request,
2763     (dump_func)dump_suspend_thread_request,
2764     (dump_func)dump_resume_thread_request,
2765     (dump_func)dump_load_dll_request,
2766     (dump_func)dump_unload_dll_request,
2767     (dump_func)dump_queue_apc_request,
2768     (dump_func)dump_get_apc_request,
2769     (dump_func)dump_close_handle_request,
2770     (dump_func)dump_set_handle_info_request,
2771     (dump_func)dump_dup_handle_request,
2772     (dump_func)dump_open_process_request,
2773     (dump_func)dump_open_thread_request,
2774     (dump_func)dump_select_request,
2775     (dump_func)dump_create_event_request,
2776     (dump_func)dump_event_op_request,
2777     (dump_func)dump_open_event_request,
2778     (dump_func)dump_create_mutex_request,
2779     (dump_func)dump_release_mutex_request,
2780     (dump_func)dump_open_mutex_request,
2781     (dump_func)dump_create_semaphore_request,
2782     (dump_func)dump_release_semaphore_request,
2783     (dump_func)dump_open_semaphore_request,
2784     (dump_func)dump_create_file_request,
2785     (dump_func)dump_alloc_file_handle_request,
2786     (dump_func)dump_get_handle_fd_request,
2787     (dump_func)dump_flush_file_request,
2788     (dump_func)dump_lock_file_request,
2789     (dump_func)dump_unlock_file_request,
2790     (dump_func)dump_create_socket_request,
2791     (dump_func)dump_accept_socket_request,
2792     (dump_func)dump_set_socket_event_request,
2793     (dump_func)dump_get_socket_event_request,
2794     (dump_func)dump_enable_socket_event_request,
2795     (dump_func)dump_set_socket_deferred_request,
2796     (dump_func)dump_alloc_console_request,
2797     (dump_func)dump_free_console_request,
2798     (dump_func)dump_get_console_renderer_events_request,
2799     (dump_func)dump_open_console_request,
2800     (dump_func)dump_get_console_wait_event_request,
2801     (dump_func)dump_get_console_mode_request,
2802     (dump_func)dump_set_console_mode_request,
2803     (dump_func)dump_set_console_input_info_request,
2804     (dump_func)dump_get_console_input_info_request,
2805     (dump_func)dump_append_console_input_history_request,
2806     (dump_func)dump_get_console_input_history_request,
2807     (dump_func)dump_create_console_output_request,
2808     (dump_func)dump_set_console_output_info_request,
2809     (dump_func)dump_get_console_output_info_request,
2810     (dump_func)dump_write_console_input_request,
2811     (dump_func)dump_read_console_input_request,
2812     (dump_func)dump_write_console_output_request,
2813     (dump_func)dump_fill_console_output_request,
2814     (dump_func)dump_read_console_output_request,
2815     (dump_func)dump_move_console_output_request,
2816     (dump_func)dump_send_console_signal_request,
2817     (dump_func)dump_create_change_notification_request,
2818     (dump_func)dump_next_change_notification_request,
2819     (dump_func)dump_create_mapping_request,
2820     (dump_func)dump_open_mapping_request,
2821     (dump_func)dump_get_mapping_info_request,
2822     (dump_func)dump_create_snapshot_request,
2823     (dump_func)dump_next_process_request,
2824     (dump_func)dump_next_thread_request,
2825     (dump_func)dump_next_module_request,
2826     (dump_func)dump_wait_debug_event_request,
2827     (dump_func)dump_queue_exception_event_request,
2828     (dump_func)dump_get_exception_status_request,
2829     (dump_func)dump_output_debug_string_request,
2830     (dump_func)dump_continue_debug_event_request,
2831     (dump_func)dump_debug_process_request,
2832     (dump_func)dump_debug_break_request,
2833     (dump_func)dump_set_debugger_kill_on_exit_request,
2834     (dump_func)dump_read_process_memory_request,
2835     (dump_func)dump_write_process_memory_request,
2836     (dump_func)dump_create_key_request,
2837     (dump_func)dump_open_key_request,
2838     (dump_func)dump_delete_key_request,
2839     (dump_func)dump_flush_key_request,
2840     (dump_func)dump_enum_key_request,
2841     (dump_func)dump_set_key_value_request,
2842     (dump_func)dump_get_key_value_request,
2843     (dump_func)dump_enum_key_value_request,
2844     (dump_func)dump_delete_key_value_request,
2845     (dump_func)dump_load_registry_request,
2846     (dump_func)dump_unload_registry_request,
2847     (dump_func)dump_save_registry_request,
2848     (dump_func)dump_load_user_registries_request,
2849     (dump_func)dump_set_registry_notification_request,
2850     (dump_func)dump_create_timer_request,
2851     (dump_func)dump_open_timer_request,
2852     (dump_func)dump_set_timer_request,
2853     (dump_func)dump_cancel_timer_request,
2854     (dump_func)dump_get_timer_info_request,
2855     (dump_func)dump_get_thread_context_request,
2856     (dump_func)dump_set_thread_context_request,
2857     (dump_func)dump_get_selector_entry_request,
2858     (dump_func)dump_add_atom_request,
2859     (dump_func)dump_delete_atom_request,
2860     (dump_func)dump_find_atom_request,
2861     (dump_func)dump_get_atom_name_request,
2862     (dump_func)dump_init_atom_table_request,
2863     (dump_func)dump_get_msg_queue_request,
2864     (dump_func)dump_set_queue_mask_request,
2865     (dump_func)dump_get_queue_status_request,
2866     (dump_func)dump_wait_input_idle_request,
2867     (dump_func)dump_send_message_request,
2868     (dump_func)dump_get_message_request,
2869     (dump_func)dump_reply_message_request,
2870     (dump_func)dump_accept_hardware_message_request,
2871     (dump_func)dump_get_message_reply_request,
2872     (dump_func)dump_set_win_timer_request,
2873     (dump_func)dump_kill_win_timer_request,
2874     (dump_func)dump_get_serial_info_request,
2875     (dump_func)dump_set_serial_info_request,
2876     (dump_func)dump_register_async_request,
2877     (dump_func)dump_cancel_async_request,
2878     (dump_func)dump_create_named_pipe_request,
2879     (dump_func)dump_open_named_pipe_request,
2880     (dump_func)dump_connect_named_pipe_request,
2881     (dump_func)dump_wait_named_pipe_request,
2882     (dump_func)dump_disconnect_named_pipe_request,
2883     (dump_func)dump_get_named_pipe_info_request,
2884     (dump_func)dump_create_window_request,
2885     (dump_func)dump_destroy_window_request,
2886     (dump_func)dump_set_window_owner_request,
2887     (dump_func)dump_get_window_info_request,
2888     (dump_func)dump_set_window_info_request,
2889     (dump_func)dump_set_parent_request,
2890     (dump_func)dump_get_window_parents_request,
2891     (dump_func)dump_get_window_children_request,
2892     (dump_func)dump_get_window_children_from_point_request,
2893     (dump_func)dump_get_window_tree_request,
2894     (dump_func)dump_set_window_pos_request,
2895     (dump_func)dump_get_window_rectangles_request,
2896     (dump_func)dump_get_window_text_request,
2897     (dump_func)dump_set_window_text_request,
2898     (dump_func)dump_get_windows_offset_request,
2899     (dump_func)dump_get_visible_region_request,
2900     (dump_func)dump_get_window_region_request,
2901     (dump_func)dump_set_window_region_request,
2902     (dump_func)dump_get_update_region_request,
2903     (dump_func)dump_update_window_zorder_request,
2904     (dump_func)dump_redraw_window_request,
2905     (dump_func)dump_set_window_property_request,
2906     (dump_func)dump_remove_window_property_request,
2907     (dump_func)dump_get_window_property_request,
2908     (dump_func)dump_get_window_properties_request,
2909     (dump_func)dump_attach_thread_input_request,
2910     (dump_func)dump_get_thread_input_request,
2911     (dump_func)dump_get_key_state_request,
2912     (dump_func)dump_set_key_state_request,
2913     (dump_func)dump_set_foreground_window_request,
2914     (dump_func)dump_set_focus_window_request,
2915     (dump_func)dump_set_active_window_request,
2916     (dump_func)dump_set_capture_window_request,
2917     (dump_func)dump_set_caret_window_request,
2918     (dump_func)dump_set_caret_info_request,
2919     (dump_func)dump_set_hook_request,
2920     (dump_func)dump_remove_hook_request,
2921     (dump_func)dump_start_hook_chain_request,
2922     (dump_func)dump_finish_hook_chain_request,
2923     (dump_func)dump_get_next_hook_request,
2924     (dump_func)dump_create_class_request,
2925     (dump_func)dump_destroy_class_request,
2926     (dump_func)dump_set_class_info_request,
2927     (dump_func)dump_set_clipboard_info_request,
2928     (dump_func)dump_open_token_request,
2929     (dump_func)dump_set_global_windows_request,
2930     (dump_func)dump_adjust_token_privileges_request,
2931     (dump_func)dump_get_token_privileges_request,
2932     (dump_func)dump_duplicate_token_request,
2933     (dump_func)dump_create_mailslot_request,
2934     (dump_func)dump_open_mailslot_request,
2935     (dump_func)dump_set_mailslot_info_request,
2936 };
2937
2938 static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
2939     (dump_func)dump_new_process_reply,
2940     (dump_func)dump_get_new_process_info_reply,
2941     (dump_func)dump_new_thread_reply,
2942     (dump_func)0,
2943     (dump_func)dump_init_process_reply,
2944     (dump_func)dump_get_startup_info_reply,
2945     (dump_func)0,
2946     (dump_func)dump_init_thread_reply,
2947     (dump_func)dump_terminate_process_reply,
2948     (dump_func)dump_terminate_thread_reply,
2949     (dump_func)dump_get_process_info_reply,
2950     (dump_func)0,
2951     (dump_func)dump_get_thread_info_reply,
2952     (dump_func)0,
2953     (dump_func)dump_get_dll_info_reply,
2954     (dump_func)dump_suspend_thread_reply,
2955     (dump_func)dump_resume_thread_reply,
2956     (dump_func)0,
2957     (dump_func)0,
2958     (dump_func)0,
2959     (dump_func)dump_get_apc_reply,
2960     (dump_func)dump_close_handle_reply,
2961     (dump_func)dump_set_handle_info_reply,
2962     (dump_func)dump_dup_handle_reply,
2963     (dump_func)dump_open_process_reply,
2964     (dump_func)dump_open_thread_reply,
2965     (dump_func)0,
2966     (dump_func)dump_create_event_reply,
2967     (dump_func)0,
2968     (dump_func)dump_open_event_reply,
2969     (dump_func)dump_create_mutex_reply,
2970     (dump_func)dump_release_mutex_reply,
2971     (dump_func)dump_open_mutex_reply,
2972     (dump_func)dump_create_semaphore_reply,
2973     (dump_func)dump_release_semaphore_reply,
2974     (dump_func)dump_open_semaphore_reply,
2975     (dump_func)dump_create_file_reply,
2976     (dump_func)dump_alloc_file_handle_reply,
2977     (dump_func)dump_get_handle_fd_reply,
2978     (dump_func)dump_flush_file_reply,
2979     (dump_func)dump_lock_file_reply,
2980     (dump_func)0,
2981     (dump_func)dump_create_socket_reply,
2982     (dump_func)dump_accept_socket_reply,
2983     (dump_func)0,
2984     (dump_func)dump_get_socket_event_reply,
2985     (dump_func)0,
2986     (dump_func)0,
2987     (dump_func)dump_alloc_console_reply,
2988     (dump_func)0,
2989     (dump_func)dump_get_console_renderer_events_reply,
2990     (dump_func)dump_open_console_reply,
2991     (dump_func)dump_get_console_wait_event_reply,
2992     (dump_func)dump_get_console_mode_reply,
2993     (dump_func)0,
2994     (dump_func)0,
2995     (dump_func)dump_get_console_input_info_reply,
2996     (dump_func)0,
2997     (dump_func)dump_get_console_input_history_reply,
2998     (dump_func)dump_create_console_output_reply,
2999     (dump_func)0,
3000     (dump_func)dump_get_console_output_info_reply,
3001     (dump_func)dump_write_console_input_reply,
3002     (dump_func)dump_read_console_input_reply,
3003     (dump_func)dump_write_console_output_reply,
3004     (dump_func)dump_fill_console_output_reply,
3005     (dump_func)dump_read_console_output_reply,
3006     (dump_func)0,
3007     (dump_func)0,
3008     (dump_func)dump_create_change_notification_reply,
3009     (dump_func)0,
3010     (dump_func)dump_create_mapping_reply,
3011     (dump_func)dump_open_mapping_reply,
3012     (dump_func)dump_get_mapping_info_reply,
3013     (dump_func)dump_create_snapshot_reply,
3014     (dump_func)dump_next_process_reply,
3015     (dump_func)dump_next_thread_reply,
3016     (dump_func)dump_next_module_reply,
3017     (dump_func)dump_wait_debug_event_reply,
3018     (dump_func)dump_queue_exception_event_reply,
3019     (dump_func)dump_get_exception_status_reply,
3020     (dump_func)0,
3021     (dump_func)0,
3022     (dump_func)0,
3023     (dump_func)dump_debug_break_reply,
3024     (dump_func)0,
3025     (dump_func)dump_read_process_memory_reply,
3026     (dump_func)0,
3027     (dump_func)dump_create_key_reply,
3028     (dump_func)dump_open_key_reply,
3029     (dump_func)0,
3030     (dump_func)0,
3031     (dump_func)dump_enum_key_reply,
3032     (dump_func)0,
3033     (dump_func)dump_get_key_value_reply,
3034     (dump_func)dump_enum_key_value_reply,
3035     (dump_func)0,
3036     (dump_func)0,
3037     (dump_func)0,
3038     (dump_func)0,
3039     (dump_func)0,
3040     (dump_func)0,
3041     (dump_func)dump_create_timer_reply,
3042     (dump_func)dump_open_timer_reply,
3043     (dump_func)dump_set_timer_reply,
3044     (dump_func)dump_cancel_timer_reply,
3045     (dump_func)dump_get_timer_info_reply,
3046     (dump_func)dump_get_thread_context_reply,
3047     (dump_func)0,
3048     (dump_func)dump_get_selector_entry_reply,
3049     (dump_func)dump_add_atom_reply,
3050     (dump_func)0,
3051     (dump_func)dump_find_atom_reply,
3052     (dump_func)dump_get_atom_name_reply,
3053     (dump_func)0,
3054     (dump_func)dump_get_msg_queue_reply,
3055     (dump_func)dump_set_queue_mask_reply,
3056     (dump_func)dump_get_queue_status_reply,
3057     (dump_func)dump_wait_input_idle_reply,
3058     (dump_func)0,
3059     (dump_func)dump_get_message_reply,
3060     (dump_func)0,
3061     (dump_func)0,
3062     (dump_func)dump_get_message_reply_reply,
3063     (dump_func)dump_set_win_timer_reply,
3064     (dump_func)0,
3065     (dump_func)dump_get_serial_info_reply,
3066     (dump_func)0,
3067     (dump_func)0,
3068     (dump_func)0,
3069     (dump_func)dump_create_named_pipe_reply,
3070     (dump_func)dump_open_named_pipe_reply,
3071     (dump_func)0,
3072     (dump_func)0,
3073     (dump_func)dump_disconnect_named_pipe_reply,
3074     (dump_func)dump_get_named_pipe_info_reply,
3075     (dump_func)dump_create_window_reply,
3076     (dump_func)0,
3077     (dump_func)dump_set_window_owner_reply,
3078     (dump_func)dump_get_window_info_reply,
3079     (dump_func)dump_set_window_info_reply,
3080     (dump_func)dump_set_parent_reply,
3081     (dump_func)dump_get_window_parents_reply,
3082     (dump_func)dump_get_window_children_reply,
3083     (dump_func)dump_get_window_children_from_point_reply,
3084     (dump_func)dump_get_window_tree_reply,
3085     (dump_func)dump_set_window_pos_reply,
3086     (dump_func)dump_get_window_rectangles_reply,
3087     (dump_func)dump_get_window_text_reply,
3088     (dump_func)0,
3089     (dump_func)dump_get_windows_offset_reply,
3090     (dump_func)dump_get_visible_region_reply,
3091     (dump_func)dump_get_window_region_reply,
3092     (dump_func)0,
3093     (dump_func)dump_get_update_region_reply,
3094     (dump_func)0,
3095     (dump_func)0,
3096     (dump_func)0,
3097     (dump_func)dump_remove_window_property_reply,
3098     (dump_func)dump_get_window_property_reply,
3099     (dump_func)dump_get_window_properties_reply,
3100     (dump_func)0,
3101     (dump_func)dump_get_thread_input_reply,
3102     (dump_func)dump_get_key_state_reply,
3103     (dump_func)0,
3104     (dump_func)dump_set_foreground_window_reply,
3105     (dump_func)dump_set_focus_window_reply,
3106     (dump_func)dump_set_active_window_reply,
3107     (dump_func)dump_set_capture_window_reply,
3108     (dump_func)dump_set_caret_window_reply,
3109     (dump_func)dump_set_caret_info_reply,
3110     (dump_func)dump_set_hook_reply,
3111     (dump_func)0,
3112     (dump_func)dump_start_hook_chain_reply,
3113     (dump_func)0,
3114     (dump_func)dump_get_next_hook_reply,
3115     (dump_func)0,
3116     (dump_func)dump_destroy_class_reply,
3117     (dump_func)dump_set_class_info_reply,
3118     (dump_func)dump_set_clipboard_info_reply,
3119     (dump_func)dump_open_token_reply,
3120     (dump_func)dump_set_global_windows_reply,
3121     (dump_func)dump_adjust_token_privileges_reply,
3122     (dump_func)dump_get_token_privileges_reply,
3123     (dump_func)dump_duplicate_token_reply,
3124     (dump_func)dump_create_mailslot_reply,
3125     (dump_func)dump_open_mailslot_reply,
3126     (dump_func)dump_set_mailslot_info_reply,
3127 };
3128
3129 static const char * const req_names[REQ_NB_REQUESTS] = {
3130     "new_process",
3131     "get_new_process_info",
3132     "new_thread",
3133     "boot_done",
3134     "init_process",
3135     "get_startup_info",
3136     "init_process_done",
3137     "init_thread",
3138     "terminate_process",
3139     "terminate_thread",
3140     "get_process_info",
3141     "set_process_info",
3142     "get_thread_info",
3143     "set_thread_info",
3144     "get_dll_info",
3145     "suspend_thread",
3146     "resume_thread",
3147     "load_dll",
3148     "unload_dll",
3149     "queue_apc",
3150     "get_apc",
3151     "close_handle",
3152     "set_handle_info",
3153     "dup_handle",
3154     "open_process",
3155     "open_thread",
3156     "select",
3157     "create_event",
3158     "event_op",
3159     "open_event",
3160     "create_mutex",
3161     "release_mutex",
3162     "open_mutex",
3163     "create_semaphore",
3164     "release_semaphore",
3165     "open_semaphore",
3166     "create_file",
3167     "alloc_file_handle",
3168     "get_handle_fd",
3169     "flush_file",
3170     "lock_file",
3171     "unlock_file",
3172     "create_socket",
3173     "accept_socket",
3174     "set_socket_event",
3175     "get_socket_event",
3176     "enable_socket_event",
3177     "set_socket_deferred",
3178     "alloc_console",
3179     "free_console",
3180     "get_console_renderer_events",
3181     "open_console",
3182     "get_console_wait_event",
3183     "get_console_mode",
3184     "set_console_mode",
3185     "set_console_input_info",
3186     "get_console_input_info",
3187     "append_console_input_history",
3188     "get_console_input_history",
3189     "create_console_output",
3190     "set_console_output_info",
3191     "get_console_output_info",
3192     "write_console_input",
3193     "read_console_input",
3194     "write_console_output",
3195     "fill_console_output",
3196     "read_console_output",
3197     "move_console_output",
3198     "send_console_signal",
3199     "create_change_notification",
3200     "next_change_notification",
3201     "create_mapping",
3202     "open_mapping",
3203     "get_mapping_info",
3204     "create_snapshot",
3205     "next_process",
3206     "next_thread",
3207     "next_module",
3208     "wait_debug_event",
3209     "queue_exception_event",
3210     "get_exception_status",
3211     "output_debug_string",
3212     "continue_debug_event",
3213     "debug_process",
3214     "debug_break",
3215     "set_debugger_kill_on_exit",
3216     "read_process_memory",
3217     "write_process_memory",
3218     "create_key",
3219     "open_key",
3220     "delete_key",
3221     "flush_key",
3222     "enum_key",
3223     "set_key_value",
3224     "get_key_value",
3225     "enum_key_value",
3226     "delete_key_value",
3227     "load_registry",
3228     "unload_registry",
3229     "save_registry",
3230     "load_user_registries",
3231     "set_registry_notification",
3232     "create_timer",
3233     "open_timer",
3234     "set_timer",
3235     "cancel_timer",
3236     "get_timer_info",
3237     "get_thread_context",
3238     "set_thread_context",
3239     "get_selector_entry",
3240     "add_atom",
3241     "delete_atom",
3242     "find_atom",
3243     "get_atom_name",
3244     "init_atom_table",
3245     "get_msg_queue",
3246     "set_queue_mask",
3247     "get_queue_status",
3248     "wait_input_idle",
3249     "send_message",
3250     "get_message",
3251     "reply_message",
3252     "accept_hardware_message",
3253     "get_message_reply",
3254     "set_win_timer",
3255     "kill_win_timer",
3256     "get_serial_info",
3257     "set_serial_info",
3258     "register_async",
3259     "cancel_async",
3260     "create_named_pipe",
3261     "open_named_pipe",
3262     "connect_named_pipe",
3263     "wait_named_pipe",
3264     "disconnect_named_pipe",
3265     "get_named_pipe_info",
3266     "create_window",
3267     "destroy_window",
3268     "set_window_owner",
3269     "get_window_info",
3270     "set_window_info",
3271     "set_parent",
3272     "get_window_parents",
3273     "get_window_children",
3274     "get_window_children_from_point",
3275     "get_window_tree",
3276     "set_window_pos",
3277     "get_window_rectangles",
3278     "get_window_text",
3279     "set_window_text",
3280     "get_windows_offset",
3281     "get_visible_region",
3282     "get_window_region",
3283     "set_window_region",
3284     "get_update_region",
3285     "update_window_zorder",
3286     "redraw_window",
3287     "set_window_property",
3288     "remove_window_property",
3289     "get_window_property",
3290     "get_window_properties",
3291     "attach_thread_input",
3292     "get_thread_input",
3293     "get_key_state",
3294     "set_key_state",
3295     "set_foreground_window",
3296     "set_focus_window",
3297     "set_active_window",
3298     "set_capture_window",
3299     "set_caret_window",
3300     "set_caret_info",
3301     "set_hook",
3302     "remove_hook",
3303     "start_hook_chain",
3304     "finish_hook_chain",
3305     "get_next_hook",
3306     "create_class",
3307     "destroy_class",
3308     "set_class_info",
3309     "set_clipboard_info",
3310     "open_token",
3311     "set_global_windows",
3312     "adjust_token_privileges",
3313     "get_token_privileges",
3314     "duplicate_token",
3315     "create_mailslot",
3316     "open_mailslot",
3317     "set_mailslot_info",
3318 };
3319
3320 /* ### make_requests end ### */
3321 /* Everything above this line is generated automatically by tools/make_requests */
3322
3323 static const char *get_status_name( unsigned int status )
3324 {
3325 #define NAME(status)       { #status, STATUS_##status }
3326 #define NAME_WIN32(error)  { #error, 0xc0010000 | error }
3327     static const struct
3328     {
3329         const char  *name;
3330         unsigned int value;
3331     } status_names[] =
3332     {
3333         NAME(ACCESS_DENIED),
3334         NAME(ACCESS_VIOLATION),
3335         NAME(ALIAS_EXISTS),
3336         NAME(BUFFER_OVERFLOW),
3337         NAME(CHILD_MUST_BE_VOLATILE),
3338         NAME(DIRECTORY_NOT_EMPTY),
3339         NAME(DISK_FULL),
3340         NAME(DLL_NOT_FOUND),
3341         NAME(FILE_IS_A_DIRECTORY),
3342         NAME(FILE_LOCK_CONFLICT),
3343         NAME(INVALID_FILE_FOR_SECTION),
3344         NAME(INVALID_HANDLE),
3345         NAME(INVALID_PARAMETER),
3346         NAME(KEY_DELETED),
3347         NAME(MEDIA_WRITE_PROTECTED),
3348         NAME(MUTANT_NOT_OWNED),
3349         NAME(NOT_A_DIRECTORY),
3350         NAME(NOT_IMPLEMENTED),
3351         NAME(NOT_REGISTRY_FILE),
3352         NAME(NO_DATA_DETECTED),
3353         NAME(NO_MEMORY),
3354         NAME(NO_MORE_ENTRIES),
3355         NAME(NO_MORE_FILES),
3356         NAME(NO_SUCH_FILE),
3357         NAME(OBJECT_NAME_COLLISION),
3358         NAME(OBJECT_NAME_INVALID),
3359         NAME(OBJECT_NAME_NOT_FOUND),
3360         NAME(OBJECT_PATH_INVALID),
3361         NAME(OBJECT_TYPE_MISMATCH),
3362         NAME(PENDING),
3363         NAME(PIPE_BUSY),
3364         NAME(PIPE_CONNECTED),
3365         NAME(PIPE_DISCONNECTED),
3366         NAME(PIPE_LISTENING),
3367         NAME(PIPE_NOT_AVAILABLE),
3368         NAME(SEMAPHORE_LIMIT_EXCEEDED),
3369         NAME(SHARING_VIOLATION),
3370         NAME(SUSPEND_COUNT_EXCEEDED),
3371         NAME(TIMEOUT),
3372         NAME(USER_APC),
3373         NAME(WAS_LOCKED),
3374         NAME_WIN32(ERROR_INVALID_INDEX),
3375         NAME_WIN32(ERROR_INVALID_THREAD_ID),
3376         NAME_WIN32(ERROR_NEGATIVE_SEEK),
3377         NAME_WIN32(ERROR_SEEK),
3378         { NULL, 0 }  /* terminator */
3379     };
3380 #undef NAME
3381
3382     int i;
3383     static char buffer[10];
3384
3385     if (status)
3386     {
3387         for (i = 0; status_names[i].name; i++)
3388             if (status_names[i].value == status) return status_names[i].name;
3389     }
3390     sprintf( buffer, "%x", status );
3391     return buffer;
3392 }
3393
3394 void trace_request(void)
3395 {
3396     enum request req = current->req.request_header.req;
3397     if (req < REQ_NB_REQUESTS)
3398     {
3399         fprintf( stderr, "%04x: %s(", current->id, req_names[req] );
3400         if (req_dumpers[req])
3401         {
3402             cur_pos = 0;
3403             cur_data = get_req_data();
3404             cur_size = get_req_data_size();
3405             req_dumpers[req]( &current->req );
3406         }
3407         fprintf( stderr, " )\n" );
3408     }
3409     else fprintf( stderr, "%04x: %d(?)\n", current->id, req );
3410 }
3411
3412 void trace_reply( enum request req, const union generic_reply *reply )
3413 {
3414     if (req < REQ_NB_REQUESTS)
3415     {
3416         fprintf( stderr, "%04x: %s() = %s",
3417                  current->id, req_names[req], get_status_name(current->error) );
3418         if (reply_dumpers[req])
3419         {
3420             fprintf( stderr, " {" );
3421             cur_pos = 0;
3422             cur_data = current->reply_data;
3423             cur_size = reply->reply_header.reply_size;
3424             reply_dumpers[req]( reply );
3425             fprintf( stderr, " }" );
3426         }
3427         fputc( '\n', stderr );
3428     }
3429     else fprintf( stderr, "%04x: %d() = %s\n",
3430                   current->id, req, get_status_name(current->error) );
3431 }