server/trace.c

   1 /*
   2  * Server request tracing
   3  *
   4  * Copyright (C) 1999 Alexandre Julliard
   5  */
   6
   7 #include "config.h"
   8
   9 #include <ctype.h>
  10 #include <stdio.h>
  11 #include <sys/types.h>
  12 #include <sys/uio.h>
  13
  14 #include "winnt.h"
  15 #include "winbase.h"
  16 #include "wincon.h"
  17 #include "request.h"
  18 #include "unicode.h"
  19
  20 static int cur_pos;
  21 static const void *cur_data;
  22 static int cur_size;
  23
  24 /* utility functions */
  25
  26 inline static void remove_data( size_t size )
  27 {
  28     cur_data = (const char *)cur_data + size;
  29     cur_size -= size;
  30 }
  31
  32 static void dump_uints( const int *ptr, int len )
  33 {
  34     fputc( '{', stderr );
  35     while (len > 0)
  36     {
  37         fprintf( stderr, "%08x", *ptr++ );
  38         if (--len) fputc( ',', stderr );
  39     }
  40     fputc( '}', stderr );
  41 }
  42
  43 static void dump_rectangle( const rectangle_t *rect )
  44 {
  45     fprintf( stderr, "{%d,%d;%d,%d}",
  46              rect->left, rect->top, rect->right, rect->bottom );
  47 }
  48
  49 static void dump_char_info( const char_info_t *info )
  50 {
  51     fprintf( stderr, "{'" );
  52     dump_strW( &info->ch, 1, stderr, "\'\'" );
  53     fprintf( stderr, "',%04x}", info->attr );
  54 }
  55
  56 static void dump_context( const CONTEXT *context )
  57 {
  58 #ifdef __i386__
  59     fprintf( stderr, "{flags=%08lx,eax=%08lx,ebx=%08lx,ecx=%08lx,edx=%08lx,esi=%08lx,edi=%08lx,"
  60              "ebp=%08lx,eip=%08lx,esp=%08lx,eflags=%08lx,cs=%04lx,ds=%04lx,es=%04lx,"
  61              "fs=%04lx,gs=%04lx,dr0=%08lx,dr1=%08lx,dr2=%08lx,dr3=%08lx,dr6=%08lx,dr7=%08lx,",
  62              context->ContextFlags, context->Eax, context->Ebx, context->Ecx, context->Edx,
  63              context->Esi, context->Edi, context->Ebp, context->Eip, context->Esp, context->EFlags,
  64              context->SegCs, context->SegDs, context->SegEs, context->SegFs, context->SegGs,
  65              context->Dr0, context->Dr1, context->Dr2, context->Dr3, context->Dr6, context->Dr7 );
  66     fprintf( stderr, "float=" );
  67     dump_uints( (int *)&context->FloatSave, sizeof(context->FloatSave) / sizeof(int) );
  68     fprintf( stderr, "}" );
  69 #else
  70     dump_uints( (int *)context, sizeof(*context) / sizeof(int) );
  71 #endif
  72 }
  73
  74 static void dump_exc_record( const EXCEPTION_RECORD *rec )
  75 {
  76     int i;
  77     fprintf( stderr, "{code=%lx,flags=%lx,rec=%p,addr=%p,params={",
  78              rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionRecord,
  79              rec->ExceptionAddress );
  80     for (i = 0; i < min(rec->NumberParameters,EXCEPTION_MAXIMUM_PARAMETERS); i++)
  81     {
  82         if (i) fputc( ',', stderr );
  83         fprintf( stderr, "%lx", rec->ExceptionInformation[i] );
  84     }
  85     fputc( '}', stderr );
  86 }
  87
  88 static void dump_varargs_ints( size_t size )
  89 {
  90     const int *data = cur_data;
  91     size_t len = size / sizeof(*data);
  92
  93     fputc( '{', stderr );
  94     while (len > 0)
  95     {
  96         fprintf( stderr, "%d", *data++ );
  97         if (--len) fputc( ',', stderr );
  98     }
  99     fputc( '}', stderr );
 100     remove_data( size );
 101 }
 102
 103 static void dump_varargs_handles( size_t size )
 104 {
 105     const handle_t *data = cur_data;
 106     size_t len = size / sizeof(*data);
 107
 108     fputc( '{', stderr );
 109     while (len > 0)
 110     {
 111         fprintf( stderr, "%d", *data++ );
 112         if (--len) fputc( ',', stderr );
 113     }
 114     fputc( '}', stderr );
 115     remove_data( size );
 116 }
 117
 118 static void dump_varargs_ptrs( size_t size )
 119 {
 120     void * const *data = cur_data;
 121     size_t len = size / sizeof(*data);
 122
 123     fputc( '{', stderr );
 124     while (len > 0)
 125     {
 126         fprintf( stderr, "%p", *data++ );
 127         if (--len) fputc( ',', stderr );
 128     }
 129     fputc( '}', stderr );
 130     remove_data( size );
 131 }
 132
 133 static void dump_varargs_user_handles( size_t size )
 134 {
 135     const user_handle_t *data = cur_data;
 136     size_t len = size / sizeof(*data);
 137
 138     fputc( '{', stderr );
 139     while (len > 0)
 140     {
 141         fprintf( stderr, "%08x", *data++ );
 142         if (--len) fputc( ',', stderr );
 143     }
 144     fputc( '}', stderr );
 145     remove_data( size );
 146 }
 147
 148 static void dump_varargs_bytes( size_t size )
 149 {
 150     const unsigned char *data = cur_data;
 151     size_t len = size;
 152
 153     fputc( '{', stderr );
 154     while (len > 0)
 155     {
 156         fprintf( stderr, "%02x", *data++ );
 157         if (--len) fputc( ',', stderr );
 158     }
 159     fputc( '}', stderr );
 160     remove_data( size );
 161 }
 162
 163 static void dump_varargs_string( size_t size )
 164 {
 165     fprintf( stderr, "\"%.*s\"", (int)size, (char *)cur_data );
 166     remove_data( size );
 167 }
 168
 169 static void dump_varargs_unicode_str( size_t size )
 170 {
 171     fprintf( stderr, "L\"" );
 172     dump_strW( cur_data, size / sizeof(WCHAR), stderr, "\"\"" );
 173     fputc( '\"', stderr );
 174     remove_data( size );
 175 }
 176
 177 static void dump_varargs_context( size_t size )
 178 {
 179     dump_context( cur_data );
 180     remove_data( size );
 181 }
 182
 183 static void dump_varargs_exc_event( size_t size )
 184 {
 185     const CONTEXT *ptr = cur_data;
 186     fprintf( stderr, "{context=" );
 187     dump_context( ptr );
 188     fprintf( stderr, ",rec=" );
 189     dump_exc_record( (EXCEPTION_RECORD *)(ptr + 1) );
 190     fputc( '}', stderr );
 191     remove_data( size );
 192 }
 193
 194 static void dump_varargs_debug_event( size_t size )
 195 {
 196     const debug_event_t *event = cur_data;
 197
 198     if (!size)
 199     {
 200         fprintf( stderr, "{}" );
 201         return;
 202     }
 203     switch(event->code)
 204     {
 205     case EXCEPTION_DEBUG_EVENT:
 206         fprintf( stderr, "{exception," );
 207         dump_exc_record( &event->info.exception.record );
 208         fprintf( stderr, ",first=%d}", event->info.exception.first );
 209         break;
 210     case CREATE_THREAD_DEBUG_EVENT:
 211         fprintf( stderr, "{create_thread,thread=%d,teb=%p,start=%p}",
 212                  event->info.create_thread.handle, event->info.create_thread.teb,
 213                  event->info.create_thread.start );
 214         break;
 215     case CREATE_PROCESS_DEBUG_EVENT:
 216         fprintf( stderr, "{create_process,file=%d,process=%d,thread=%d,base=%p,offset=%d,"
 217                          "size=%d,teb=%p,start=%p,name=%p,unicode=%d}",
 218                  event->info.create_process.file, event->info.create_process.process,
 219                  event->info.create_process.thread, event->info.create_process.base,
 220                  event->info.create_process.dbg_offset, event->info.create_process.dbg_size,
 221                  event->info.create_process.teb, event->info.create_process.start,
 222                  event->info.create_process.name, event->info.create_process.unicode );
 223         break;
 224     case EXIT_THREAD_DEBUG_EVENT:
 225         fprintf( stderr, "{exit_thread,code=%d}", event->info.exit.exit_code );
 226         break;
 227     case EXIT_PROCESS_DEBUG_EVENT:
 228         fprintf( stderr, "{exit_process,code=%d}", event->info.exit.exit_code );
 229         break;
 230     case LOAD_DLL_DEBUG_EVENT:
 231         fprintf( stderr, "{load_dll,file=%d,base=%p,offset=%d,size=%d,name=%p,unicode=%d}",
 232                  event->info.load_dll.handle, event->info.load_dll.base,
 233                  event->info.load_dll.dbg_offset, event->info.load_dll.dbg_size,
 234                  event->info.load_dll.name, event->info.load_dll.unicode );
 235         break;
 236     case UNLOAD_DLL_DEBUG_EVENT:
 237         fprintf( stderr, "{unload_dll,base=%p}", event->info.unload_dll.base );
 238         break;
 239     case OUTPUT_DEBUG_STRING_EVENT:
 240         fprintf( stderr, "{output_string,data=%p,unicode=%d,len=%d}",
 241                  event->info.output_string.string, event->info.output_string.unicode,
 242                  event->info.output_string.length );
 243         break;
 244     case RIP_EVENT:
 245         fprintf( stderr, "{rip,err=%d,type=%d}",
 246                  event->info.rip_info.error, event->info.rip_info.type );
 247         break;
 248     case 0:  /* zero is the code returned on timeouts */
 249         fprintf( stderr, "{}" );
 250         break;
 251     default:
 252         fprintf( stderr, "{code=??? (%d)}", event->code );
 253         break;
 254     }
 255     remove_data( size );
 256 }
 257
 258 static void dump_varargs_input_records( size_t size )
 259 {
 260     const INPUT_RECORD *rec = cur_data;
 261     size_t len = size / sizeof(*rec);
 262
 263     fputc( '{', stderr );
 264     while (len > 0)
 265     {
 266         fprintf( stderr, "{%04x,...}", rec->EventType );
 267         rec++;
 268         if (--len) fputc( ',', stderr );
 269     }
 270     fputc( '}', stderr );
 271     remove_data( size );
 272 }
 273
 274 static void dump_varargs_properties( size_t size )
 275 {
 276     const property_data_t *prop = cur_data;
 277     size_t len = size / sizeof(*prop);
 278
 279     fputc( '{', stderr );
 280     while (len > 0)
 281     {
 282         fprintf( stderr, "{atom=%04x,str=%d,handle=%08x}",
 283                  prop->atom, prop->string, prop->handle );
 284         prop++;
 285         if (--len) fputc( ',', stderr );
 286     }
 287     fputc( '}', stderr );
 288     remove_data( size );
 289 }
 290
 291 typedef void (*dump_func)( const void *req );
 292
 293 /* Everything below this line is generated automatically by tools/make_requests */
 294 /* ### make_requests begin ### */
 295
 296 static void dump_new_process_request( const struct new_process_request *req )
 297 {
 298     fprintf( stderr, " inherit_all=%d,", req->inherit_all );
 299     fprintf( stderr, " create_flags=%d,", req->create_flags );
 300     fprintf( stderr, " start_flags=%d,", req->start_flags );
 301     fprintf( stderr, " exe_file=%d,", req->exe_file );
 302     fprintf( stderr, " hstdin=%d,", req->hstdin );
 303     fprintf( stderr, " hstdout=%d,", req->hstdout );
 304     fprintf( stderr, " hstderr=%d,", req->hstderr );
 305     fprintf( stderr, " cmd_show=%d,", req->cmd_show );
 306     fprintf( stderr, " filename=" );
 307     dump_varargs_string( cur_size );
 308 }
 309
 310 static void dump_new_process_reply( const struct new_process_reply *req )
 311 {
 312     fprintf( stderr, " info=%d", req->info );
 313 }
 314
 315 static void dump_get_new_process_info_request( const struct get_new_process_info_request *req )
 316 {
 317     fprintf( stderr, " info=%d,", req->info );
 318     fprintf( stderr, " pinherit=%d,", req->pinherit );
 319     fprintf( stderr, " tinherit=%d", req->tinherit );
 320 }
 321
 322 static void dump_get_new_process_info_reply( const struct get_new_process_info_reply *req )
 323 {
 324     fprintf( stderr, " pid=%p,", req->pid );
 325     fprintf( stderr, " phandle=%d,", req->phandle );
 326     fprintf( stderr, " tid=%p,", req->tid );
 327     fprintf( stderr, " thandle=%d,", req->thandle );
 328     fprintf( stderr, " event=%d", req->event );
 329 }
 330
 331 static void dump_new_thread_request( const struct new_thread_request *req )
 332 {
 333     fprintf( stderr, " suspend=%d,", req->suspend );
 334     fprintf( stderr, " inherit=%d,", req->inherit );
 335     fprintf( stderr, " request_fd=%d", req->request_fd );
 336 }
 337
 338 static void dump_new_thread_reply( const struct new_thread_reply *req )
 339 {
 340     fprintf( stderr, " tid=%p,", req->tid );
 341     fprintf( stderr, " handle=%d", req->handle );
 342 }
 343
 344 static void dump_boot_done_request( const struct boot_done_request *req )
 345 {
 346     fprintf( stderr, " debug_level=%d", req->debug_level );
 347 }
 348
 349 static void dump_init_process_request( const struct init_process_request *req )
 350 {
 351     fprintf( stderr, " ldt_copy=%p,", req->ldt_copy );
 352     fprintf( stderr, " ppid=%d", req->ppid );
 353 }
 354
 355 static void dump_init_process_reply( const struct init_process_reply *req )
 356 {
 357     fprintf( stderr, " create_flags=%d,", req->create_flags );
 358     fprintf( stderr, " start_flags=%d,", req->start_flags );
 359     fprintf( stderr, " server_start=%08x,", req->server_start );
 360     fprintf( stderr, " exe_file=%d,", req->exe_file );
 361     fprintf( stderr, " hstdin=%d,", req->hstdin );
 362     fprintf( stderr, " hstdout=%d,", req->hstdout );
 363     fprintf( stderr, " hstderr=%d,", req->hstderr );
 364     fprintf( stderr, " cmd_show=%d,", req->cmd_show );
 365     fprintf( stderr, " filename=" );
 366     dump_varargs_string( cur_size );
 367 }
 368
 369 static void dump_init_process_done_request( const struct init_process_done_request *req )
 370 {
 371     fprintf( stderr, " module=%p,", req->module );
 372     fprintf( stderr, " entry=%p,", req->entry );
 373     fprintf( stderr, " name=%p,", req->name );
 374     fprintf( stderr, " exe_file=%d,", req->exe_file );
 375     fprintf( stderr, " gui=%d", req->gui );
 376 }
 377
 378 static void dump_init_process_done_reply( const struct init_process_done_reply *req )
 379 {
 380     fprintf( stderr, " debugged=%d", req->debugged );
 381 }
 382
 383 static void dump_init_thread_request( const struct init_thread_request *req )
 384 {
 385     fprintf( stderr, " unix_pid=%d,", req->unix_pid );
 386     fprintf( stderr, " teb=%p,", req->teb );
 387     fprintf( stderr, " entry=%p,", req->entry );
 388     fprintf( stderr, " reply_fd=%d,", req->reply_fd );
 389     fprintf( stderr, " wait_fd=%d", req->wait_fd );
 390 }
 391
 392 static void dump_init_thread_reply( const struct init_thread_reply *req )
 393 {
 394     fprintf( stderr, " pid=%p,", req->pid );
 395     fprintf( stderr, " tid=%p,", req->tid );
 396     fprintf( stderr, " boot=%d,", req->boot );
 397     fprintf( stderr, " version=%d", req->version );
 398 }
 399
 400 static void dump_terminate_process_request( const struct terminate_process_request *req )
 401 {
 402     fprintf( stderr, " handle=%d,", req->handle );
 403     fprintf( stderr, " exit_code=%d", req->exit_code );
 404 }
 405
 406 static void dump_terminate_process_reply( const struct terminate_process_reply *req )
 407 {
 408     fprintf( stderr, " self=%d", req->self );
 409 }
 410
 411 static void dump_terminate_thread_request( const struct terminate_thread_request *req )
 412 {
 413     fprintf( stderr, " handle=%d,", req->handle );
 414     fprintf( stderr, " exit_code=%d", req->exit_code );
 415 }
 416
 417 static void dump_terminate_thread_reply( const struct terminate_thread_reply *req )
 418 {
 419     fprintf( stderr, " self=%d,", req->self );
 420     fprintf( stderr, " last=%d", req->last );
 421 }
 422
 423 static void dump_get_process_info_request( const struct get_process_info_request *req )
 424 {
 425     fprintf( stderr, " handle=%d", req->handle );
 426 }
 427
 428 static void dump_get_process_info_reply( const struct get_process_info_reply *req )
 429 {
 430     fprintf( stderr, " pid=%p,", req->pid );
 431     fprintf( stderr, " debugged=%d,", req->debugged );
 432     fprintf( stderr, " exit_code=%d,", req->exit_code );
 433     fprintf( stderr, " priority=%d,", req->priority );
 434     fprintf( stderr, " process_affinity=%d,", req->process_affinity );
 435     fprintf( stderr, " system_affinity=%d", req->system_affinity );
 436 }
 437
 438 static void dump_set_process_info_request( const struct set_process_info_request *req )
 439 {
 440     fprintf( stderr, " handle=%d,", req->handle );
 441     fprintf( stderr, " mask=%d,", req->mask );
 442     fprintf( stderr, " priority=%d,", req->priority );
 443     fprintf( stderr, " affinity=%d", req->affinity );
 444 }
 445
 446 static void dump_get_thread_info_request( const struct get_thread_info_request *req )
 447 {
 448     fprintf( stderr, " handle=%d,", req->handle );
 449     fprintf( stderr, " tid_in=%p", req->tid_in );
 450 }
 451
 452 static void dump_get_thread_info_reply( const struct get_thread_info_reply *req )
 453 {
 454     fprintf( stderr, " tid=%p,", req->tid );
 455     fprintf( stderr, " teb=%p,", req->teb );
 456     fprintf( stderr, " exit_code=%d,", req->exit_code );
 457     fprintf( stderr, " priority=%d", req->priority );
 458 }
 459
 460 static void dump_set_thread_info_request( const struct set_thread_info_request *req )
 461 {
 462     fprintf( stderr, " handle=%d,", req->handle );
 463     fprintf( stderr, " mask=%d,", req->mask );
 464     fprintf( stderr, " priority=%d,", req->priority );
 465     fprintf( stderr, " affinity=%d", req->affinity );
 466 }
 467
 468 static void dump_suspend_thread_request( const struct suspend_thread_request *req )
 469 {
 470     fprintf( stderr, " handle=%d", req->handle );
 471 }
 472
 473 static void dump_suspend_thread_reply( const struct suspend_thread_reply *req )
 474 {
 475     fprintf( stderr, " count=%d", req->count );
 476 }
 477
 478 static void dump_resume_thread_request( const struct resume_thread_request *req )
 479 {
 480     fprintf( stderr, " handle=%d", req->handle );
 481 }
 482
 483 static void dump_resume_thread_reply( const struct resume_thread_reply *req )
 484 {
 485     fprintf( stderr, " count=%d", req->count );
 486 }
 487
 488 static void dump_load_dll_request( const struct load_dll_request *req )
 489 {
 490     fprintf( stderr, " handle=%d,", req->handle );
 491     fprintf( stderr, " base=%p,", req->base );
 492     fprintf( stderr, " dbg_offset=%d,", req->dbg_offset );
 493     fprintf( stderr, " dbg_size=%d,", req->dbg_size );
 494     fprintf( stderr, " name=%p", req->name );
 495 }
 496
 497 static void dump_unload_dll_request( const struct unload_dll_request *req )
 498 {
 499     fprintf( stderr, " base=%p", req->base );
 500 }
 501
 502 static void dump_queue_apc_request( const struct queue_apc_request *req )
 503 {
 504     fprintf( stderr, " handle=%d,", req->handle );
 505     fprintf( stderr, " user=%d,", req->user );
 506     fprintf( stderr, " func=%p,", req->func );
 507     fprintf( stderr, " param=%p", req->param );
 508 }
 509
 510 static void dump_get_apc_request( const struct get_apc_request *req )
 511 {
 512     fprintf( stderr, " alertable=%d", req->alertable );
 513 }
 514
 515 static void dump_get_apc_reply( const struct get_apc_reply *req )
 516 {
 517     fprintf( stderr, " func=%p,", req->func );
 518     fprintf( stderr, " type=%d,", req->type );
 519     fprintf( stderr, " args=" );
 520     dump_varargs_ptrs( cur_size );
 521 }
 522
 523 static void dump_close_handle_request( const struct close_handle_request *req )
 524 {
 525     fprintf( stderr, " handle=%d", req->handle );
 526 }
 527
 528 static void dump_close_handle_reply( const struct close_handle_reply *req )
 529 {
 530     fprintf( stderr, " fd=%d", req->fd );
 531 }
 532
 533 static void dump_set_handle_info_request( const struct set_handle_info_request *req )
 534 {
 535     fprintf( stderr, " handle=%d,", req->handle );
 536     fprintf( stderr, " flags=%d,", req->flags );
 537     fprintf( stderr, " mask=%d,", req->mask );
 538     fprintf( stderr, " fd=%d", req->fd );
 539 }
 540
 541 static void dump_set_handle_info_reply( const struct set_handle_info_reply *req )
 542 {
 543     fprintf( stderr, " old_flags=%d,", req->old_flags );
 544     fprintf( stderr, " cur_fd=%d", req->cur_fd );
 545 }
 546
 547 static void dump_dup_handle_request( const struct dup_handle_request *req )
 548 {
 549     fprintf( stderr, " src_process=%d,", req->src_process );
 550     fprintf( stderr, " src_handle=%d,", req->src_handle );
 551     fprintf( stderr, " dst_process=%d,", req->dst_process );
 552     fprintf( stderr, " access=%08x,", req->access );
 553     fprintf( stderr, " inherit=%d,", req->inherit );
 554     fprintf( stderr, " options=%d", req->options );
 555 }
 556
 557 static void dump_dup_handle_reply( const struct dup_handle_reply *req )
 558 {
 559     fprintf( stderr, " handle=%d,", req->handle );
 560     fprintf( stderr, " fd=%d", req->fd );
 561 }
 562
 563 static void dump_open_process_request( const struct open_process_request *req )
 564 {
 565     fprintf( stderr, " pid=%p,", req->pid );
 566     fprintf( stderr, " access=%08x,", req->access );
 567     fprintf( stderr, " inherit=%d", req->inherit );
 568 }
 569
 570 static void dump_open_process_reply( const struct open_process_reply *req )
 571 {
 572     fprintf( stderr, " handle=%d", req->handle );
 573 }
 574
 575 static void dump_select_request( const struct select_request *req )
 576 {
 577     fprintf( stderr, " flags=%d,", req->flags );
 578     fprintf( stderr, " cookie=%p,", req->cookie );
 579     fprintf( stderr, " sec=%d,", req->sec );
 580     fprintf( stderr, " usec=%d,", req->usec );
 581     fprintf( stderr, " handles=" );
 582     dump_varargs_handles( cur_size );
 583 }
 584
 585 static void dump_create_event_request( const struct create_event_request *req )
 586 {
 587     fprintf( stderr, " manual_reset=%d,", req->manual_reset );
 588     fprintf( stderr, " initial_state=%d,", req->initial_state );
 589     fprintf( stderr, " inherit=%d,", req->inherit );
 590     fprintf( stderr, " name=" );
 591     dump_varargs_unicode_str( cur_size );
 592 }
 593
 594 static void dump_create_event_reply( const struct create_event_reply *req )
 595 {
 596     fprintf( stderr, " handle=%d", req->handle );
 597 }
 598
 599 static void dump_event_op_request( const struct event_op_request *req )
 600 {
 601     fprintf( stderr, " handle=%d,", req->handle );
 602     fprintf( stderr, " op=%d", req->op );
 603 }
 604
 605 static void dump_open_event_request( const struct open_event_request *req )
 606 {
 607     fprintf( stderr, " access=%08x,", req->access );
 608     fprintf( stderr, " inherit=%d,", req->inherit );
 609     fprintf( stderr, " name=" );
 610     dump_varargs_unicode_str( cur_size );
 611 }
 612
 613 static void dump_open_event_reply( const struct open_event_reply *req )
 614 {
 615     fprintf( stderr, " handle=%d", req->handle );
 616 }
 617
 618 static void dump_create_mutex_request( const struct create_mutex_request *req )
 619 {
 620     fprintf( stderr, " owned=%d,", req->owned );
 621     fprintf( stderr, " inherit=%d,", req->inherit );
 622     fprintf( stderr, " name=" );
 623     dump_varargs_unicode_str( cur_size );
 624 }
 625
 626 static void dump_create_mutex_reply( const struct create_mutex_reply *req )
 627 {
 628     fprintf( stderr, " handle=%d", req->handle );
 629 }
 630
 631 static void dump_release_mutex_request( const struct release_mutex_request *req )
 632 {
 633     fprintf( stderr, " handle=%d", req->handle );
 634 }
 635
 636 static void dump_open_mutex_request( const struct open_mutex_request *req )
 637 {
 638     fprintf( stderr, " access=%08x,", req->access );
 639     fprintf( stderr, " inherit=%d,", req->inherit );
 640     fprintf( stderr, " name=" );
 641     dump_varargs_unicode_str( cur_size );
 642 }
 643
 644 static void dump_open_mutex_reply( const struct open_mutex_reply *req )
 645 {
 646     fprintf( stderr, " handle=%d", req->handle );
 647 }
 648
 649 static void dump_create_semaphore_request( const struct create_semaphore_request *req )
 650 {
 651     fprintf( stderr, " initial=%08x,", req->initial );
 652     fprintf( stderr, " max=%08x,", req->max );
 653     fprintf( stderr, " inherit=%d,", req->inherit );
 654     fprintf( stderr, " name=" );
 655     dump_varargs_unicode_str( cur_size );
 656 }
 657
 658 static void dump_create_semaphore_reply( const struct create_semaphore_reply *req )
 659 {
 660     fprintf( stderr, " handle=%d", req->handle );
 661 }
 662
 663 static void dump_release_semaphore_request( const struct release_semaphore_request *req )
 664 {
 665     fprintf( stderr, " handle=%d,", req->handle );
 666     fprintf( stderr, " count=%08x", req->count );
 667 }
 668
 669 static void dump_release_semaphore_reply( const struct release_semaphore_reply *req )
 670 {
 671     fprintf( stderr, " prev_count=%08x", req->prev_count );
 672 }
 673
 674 static void dump_open_semaphore_request( const struct open_semaphore_request *req )
 675 {
 676     fprintf( stderr, " access=%08x,", req->access );
 677     fprintf( stderr, " inherit=%d,", req->inherit );
 678     fprintf( stderr, " name=" );
 679     dump_varargs_unicode_str( cur_size );
 680 }
 681
 682 static void dump_open_semaphore_reply( const struct open_semaphore_reply *req )
 683 {
 684     fprintf( stderr, " handle=%d", req->handle );
 685 }
 686
 687 static void dump_create_file_request( const struct create_file_request *req )
 688 {
 689     fprintf( stderr, " access=%08x,", req->access );
 690     fprintf( stderr, " inherit=%d,", req->inherit );
 691     fprintf( stderr, " sharing=%08x,", req->sharing );
 692     fprintf( stderr, " create=%d,", req->create );
 693     fprintf( stderr, " attrs=%08x,", req->attrs );
 694     fprintf( stderr, " drive_type=%d,", req->drive_type );
 695     fprintf( stderr, " filename=" );
 696     dump_varargs_string( cur_size );
 697 }
 698
 699 static void dump_create_file_reply( const struct create_file_reply *req )
 700 {
 701     fprintf( stderr, " handle=%d", req->handle );
 702 }
 703
 704 static void dump_alloc_file_handle_request( const struct alloc_file_handle_request *req )
 705 {
 706     fprintf( stderr, " access=%08x,", req->access );
 707     fprintf( stderr, " inherit=%d,", req->inherit );
 708     fprintf( stderr, " fd=%d", req->fd );
 709 }
 710
 711 static void dump_alloc_file_handle_reply( const struct alloc_file_handle_reply *req )
 712 {
 713     fprintf( stderr, " handle=%d", req->handle );
 714 }
 715
 716 static void dump_get_handle_fd_request( const struct get_handle_fd_request *req )
 717 {
 718     fprintf( stderr, " handle=%d,", req->handle );
 719     fprintf( stderr, " access=%08x", req->access );
 720 }
 721
 722 static void dump_get_handle_fd_reply( const struct get_handle_fd_reply *req )
 723 {
 724     fprintf( stderr, " fd=%d,", req->fd );
 725     fprintf( stderr, " type=%d,", req->type );
 726     fprintf( stderr, " flags=%d", req->flags );
 727 }
 728
 729 static void dump_set_file_pointer_request( const struct set_file_pointer_request *req )
 730 {
 731     fprintf( stderr, " handle=%d,", req->handle );
 732     fprintf( stderr, " low=%d,", req->low );
 733     fprintf( stderr, " high=%d,", req->high );
 734     fprintf( stderr, " whence=%d", req->whence );
 735 }
 736
 737 static void dump_set_file_pointer_reply( const struct set_file_pointer_reply *req )
 738 {
 739     fprintf( stderr, " new_low=%d,", req->new_low );
 740     fprintf( stderr, " new_high=%d", req->new_high );
 741 }
 742
 743 static void dump_truncate_file_request( const struct truncate_file_request *req )
 744 {
 745     fprintf( stderr, " handle=%d", req->handle );
 746 }
 747
 748 static void dump_set_file_time_request( const struct set_file_time_request *req )
 749 {
 750     fprintf( stderr, " handle=%d,", req->handle );
 751     fprintf( stderr, " access_time=%ld,", req->access_time );
 752     fprintf( stderr, " write_time=%ld", req->write_time );
 753 }
 754
 755 static void dump_flush_file_request( const struct flush_file_request *req )
 756 {
 757     fprintf( stderr, " handle=%d", req->handle );
 758 }
 759
 760 static void dump_get_file_info_request( const struct get_file_info_request *req )
 761 {
 762     fprintf( stderr, " handle=%d", req->handle );
 763 }
 764
 765 static void dump_get_file_info_reply( const struct get_file_info_reply *req )
 766 {
 767     fprintf( stderr, " type=%d,", req->type );
 768     fprintf( stderr, " attr=%d,", req->attr );
 769     fprintf( stderr, " access_time=%ld,", req->access_time );
 770     fprintf( stderr, " write_time=%ld,", req->write_time );
 771     fprintf( stderr, " size_high=%d,", req->size_high );
 772     fprintf( stderr, " size_low=%d,", req->size_low );
 773     fprintf( stderr, " links=%d,", req->links );
 774     fprintf( stderr, " index_high=%d,", req->index_high );
 775     fprintf( stderr, " index_low=%d,", req->index_low );
 776     fprintf( stderr, " serial=%08x", req->serial );
 777 }
 778
 779 static void dump_lock_file_request( const struct lock_file_request *req )
 780 {
 781     fprintf( stderr, " handle=%d,", req->handle );
 782     fprintf( stderr, " offset_low=%08x,", req->offset_low );
 783     fprintf( stderr, " offset_high=%08x,", req->offset_high );
 784     fprintf( stderr, " count_low=%08x,", req->count_low );
 785     fprintf( stderr, " count_high=%08x", req->count_high );
 786 }
 787
 788 static void dump_unlock_file_request( const struct unlock_file_request *req )
 789 {
 790     fprintf( stderr, " handle=%d,", req->handle );
 791     fprintf( stderr, " offset_low=%08x,", req->offset_low );
 792     fprintf( stderr, " offset_high=%08x,", req->offset_high );
 793     fprintf( stderr, " count_low=%08x,", req->count_low );
 794     fprintf( stderr, " count_high=%08x", req->count_high );
 795 }
 796
 797 static void dump_create_pipe_request( const struct create_pipe_request *req )
 798 {
 799     fprintf( stderr, " inherit=%d", req->inherit );
 800 }
 801
 802 static void dump_create_pipe_reply( const struct create_pipe_reply *req )
 803 {
 804     fprintf( stderr, " handle_read=%d,", req->handle_read );
 805     fprintf( stderr, " handle_write=%d", req->handle_write );
 806 }
 807
 808 static void dump_create_socket_request( const struct create_socket_request *req )
 809 {
 810     fprintf( stderr, " access=%08x,", req->access );
 811     fprintf( stderr, " inherit=%d,", req->inherit );
 812     fprintf( stderr, " family=%d,", req->family );
 813     fprintf( stderr, " type=%d,", req->type );
 814     fprintf( stderr, " protocol=%d,", req->protocol );
 815     fprintf( stderr, " flags=%08x", req->flags );
 816 }
 817
 818 static void dump_create_socket_reply( const struct create_socket_reply *req )
 819 {
 820     fprintf( stderr, " handle=%d", req->handle );
 821 }
 822
 823 static void dump_accept_socket_request( const struct accept_socket_request *req )
 824 {
 825     fprintf( stderr, " lhandle=%d,", req->lhandle );
 826     fprintf( stderr, " access=%08x,", req->access );
 827     fprintf( stderr, " inherit=%d", req->inherit );
 828 }
 829
 830 static void dump_accept_socket_reply( const struct accept_socket_reply *req )
 831 {
 832     fprintf( stderr, " handle=%d", req->handle );
 833 }
 834
 835 static void dump_set_socket_event_request( const struct set_socket_event_request *req )
 836 {
 837     fprintf( stderr, " handle=%d,", req->handle );
 838     fprintf( stderr, " mask=%08x,", req->mask );
 839     fprintf( stderr, " event=%d", req->event );
 840 }
 841
 842 static void dump_get_socket_event_request( const struct get_socket_event_request *req )
 843 {
 844     fprintf( stderr, " handle=%d,", req->handle );
 845     fprintf( stderr, " service=%d,", req->service );
 846     fprintf( stderr, " s_event=%d,", req->s_event );
 847     fprintf( stderr, " c_event=%d", req->c_event );
 848 }
 849
 850 static void dump_get_socket_event_reply( const struct get_socket_event_reply *req )
 851 {
 852     fprintf( stderr, " mask=%08x,", req->mask );
 853     fprintf( stderr, " pmask=%08x,", req->pmask );
 854     fprintf( stderr, " state=%08x,", req->state );
 855     fprintf( stderr, " errors=" );
 856     dump_varargs_ints( cur_size );
 857 }
 858
 859 static void dump_enable_socket_event_request( const struct enable_socket_event_request *req )
 860 {
 861     fprintf( stderr, " handle=%d,", req->handle );
 862     fprintf( stderr, " mask=%08x,", req->mask );
 863     fprintf( stderr, " sstate=%08x,", req->sstate );
 864     fprintf( stderr, " cstate=%08x", req->cstate );
 865 }
 866
 867 static void dump_alloc_console_request( const struct alloc_console_request *req )
 868 {
 869     fprintf( stderr, " access=%08x,", req->access );
 870     fprintf( stderr, " inherit=%d,", req->inherit );
 871     fprintf( stderr, " pid=%p", req->pid );
 872 }
 873
 874 static void dump_alloc_console_reply( const struct alloc_console_reply *req )
 875 {
 876     fprintf( stderr, " handle_in=%d,", req->handle_in );
 877     fprintf( stderr, " event=%d", req->event );
 878 }
 879
 880 static void dump_free_console_request( const struct free_console_request *req )
 881 {
 882 }
 883
 884 static void dump_get_console_renderer_events_request( const struct get_console_renderer_events_request *req )
 885 {
 886     fprintf( stderr, " handle=%d", req->handle );
 887 }
 888
 889 static void dump_get_console_renderer_events_reply( const struct get_console_renderer_events_reply *req )
 890 {
 891     fprintf( stderr, " data=" );
 892     dump_varargs_bytes( cur_size );
 893 }
 894
 895 static void dump_open_console_request( const struct open_console_request *req )
 896 {
 897     fprintf( stderr, " from=%d,", req->from );
 898     fprintf( stderr, " access=%08x,", req->access );
 899     fprintf( stderr, " inherit=%d,", req->inherit );
 900     fprintf( stderr, " share=%d", req->share );
 901 }
 902
 903 static void dump_open_console_reply( const struct open_console_reply *req )
 904 {
 905     fprintf( stderr, " handle=%d", req->handle );
 906 }
 907
 908 static void dump_get_console_mode_request( const struct get_console_mode_request *req )
 909 {
 910     fprintf( stderr, " handle=%d", req->handle );
 911 }
 912
 913 static void dump_get_console_mode_reply( const struct get_console_mode_reply *req )
 914 {
 915     fprintf( stderr, " mode=%d", req->mode );
 916 }
 917
 918 static void dump_set_console_mode_request( const struct set_console_mode_request *req )
 919 {
 920     fprintf( stderr, " handle=%d,", req->handle );
 921     fprintf( stderr, " mode=%d", req->mode );
 922 }
 923
 924 static void dump_set_console_input_info_request( const struct set_console_input_info_request *req )
 925 {
 926     fprintf( stderr, " handle=%d,", req->handle );
 927     fprintf( stderr, " mask=%d,", req->mask );
 928     fprintf( stderr, " active_sb=%d,", req->active_sb );
 929     fprintf( stderr, " history_mode=%d,", req->history_mode );
 930     fprintf( stderr, " history_size=%d,", req->history_size );
 931     fprintf( stderr, " title=" );
 932     dump_varargs_unicode_str( cur_size );
 933 }
 934
 935 static void dump_get_console_input_info_request( const struct get_console_input_info_request *req )
 936 {
 937     fprintf( stderr, " handle=%d", req->handle );
 938 }
 939
 940 static void dump_get_console_input_info_reply( const struct get_console_input_info_reply *req )
 941 {
 942     fprintf( stderr, " history_mode=%d,", req->history_mode );
 943     fprintf( stderr, " history_size=%d,", req->history_size );
 944     fprintf( stderr, " history_index=%d,", req->history_index );
 945     fprintf( stderr, " title=" );
 946     dump_varargs_unicode_str( cur_size );
 947 }
 948
 949 static void dump_append_console_input_history_request( const struct append_console_input_history_request *req )
 950 {
 951     fprintf( stderr, " handle=%d,", req->handle );
 952     fprintf( stderr, " line=" );
 953     dump_varargs_unicode_str( cur_size );
 954 }
 955
 956 static void dump_get_console_input_history_request( const struct get_console_input_history_request *req )
 957 {
 958     fprintf( stderr, " handle=%d,", req->handle );
 959     fprintf( stderr, " index=%d", req->index );
 960 }
 961
 962 static void dump_get_console_input_history_reply( const struct get_console_input_history_reply *req )
 963 {
 964     fprintf( stderr, " total=%d,", req->total );
 965     fprintf( stderr, " line=" );
 966     dump_varargs_unicode_str( cur_size );
 967 }
 968
 969 static void dump_create_console_output_request( const struct create_console_output_request *req )
 970 {
 971     fprintf( stderr, " handle_in=%d,", req->handle_in );
 972     fprintf( stderr, " access=%d,", req->access );
 973     fprintf( stderr, " share=%d,", req->share );
 974     fprintf( stderr, " inherit=%d", req->inherit );
 975 }
 976
 977 static void dump_create_console_output_reply( const struct create_console_output_reply *req )
 978 {
 979     fprintf( stderr, " handle_out=%d", req->handle_out );
 980 }
 981
 982 static void dump_set_console_output_info_request( const struct set_console_output_info_request *req )
 983 {
 984     fprintf( stderr, " handle=%d,", req->handle );
 985     fprintf( stderr, " mask=%d,", req->mask );
 986     fprintf( stderr, " cursor_size=%d,", req->cursor_size );
 987     fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
 988     fprintf( stderr, " cursor_x=%d,", req->cursor_x );
 989     fprintf( stderr, " cursor_y=%d,", req->cursor_y );
 990     fprintf( stderr, " width=%d,", req->width );
 991     fprintf( stderr, " height=%d,", req->height );
 992     fprintf( stderr, " attr=%d,", req->attr );
 993     fprintf( stderr, " win_left=%d,", req->win_left );
 994     fprintf( stderr, " win_top=%d,", req->win_top );
 995     fprintf( stderr, " win_right=%d,", req->win_right );
 996     fprintf( stderr, " win_bottom=%d,", req->win_bottom );
 997     fprintf( stderr, " max_width=%d,", req->max_width );
 998     fprintf( stderr, " max_height=%d", req->max_height );
 999 }
1000
1001 static void dump_get_console_output_info_request( const struct get_console_output_info_request *req )
1002 {
1003     fprintf( stderr, " handle=%d", req->handle );
1004 }
1005
1006 static void dump_get_console_output_info_reply( const struct get_console_output_info_reply *req )
1007 {
1008     fprintf( stderr, " cursor_size=%d,", req->cursor_size );
1009     fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
1010     fprintf( stderr, " cursor_x=%d,", req->cursor_x );
1011     fprintf( stderr, " cursor_y=%d,", req->cursor_y );
1012     fprintf( stderr, " width=%d,", req->width );
1013     fprintf( stderr, " height=%d,", req->height );
1014     fprintf( stderr, " attr=%d,", req->attr );
1015     fprintf( stderr, " win_left=%d,", req->win_left );
1016     fprintf( stderr, " win_top=%d,", req->win_top );
1017     fprintf( stderr, " win_right=%d,", req->win_right );
1018     fprintf( stderr, " win_bottom=%d,", req->win_bottom );
1019     fprintf( stderr, " max_width=%d,", req->max_width );
1020     fprintf( stderr, " max_height=%d", req->max_height );
1021 }
1022
1023 static void dump_write_console_input_request( const struct write_console_input_request *req )
1024 {
1025     fprintf( stderr, " handle=%d,", req->handle );
1026     fprintf( stderr, " rec=" );
1027     dump_varargs_input_records( cur_size );
1028 }
1029
1030 static void dump_write_console_input_reply( const struct write_console_input_reply *req )
1031 {
1032     fprintf( stderr, " written=%d", req->written );
1033 }
1034
1035 static void dump_read_console_input_request( const struct read_console_input_request *req )
1036 {
1037     fprintf( stderr, " handle=%d,", req->handle );
1038     fprintf( stderr, " flush=%d", req->flush );
1039 }
1040
1041 static void dump_read_console_input_reply( const struct read_console_input_reply *req )
1042 {
1043     fprintf( stderr, " read=%d,", req->read );
1044     fprintf( stderr, " rec=" );
1045     dump_varargs_input_records( cur_size );
1046 }
1047
1048 static void dump_write_console_output_request( const struct write_console_output_request *req )
1049 {
1050     fprintf( stderr, " handle=%d,", req->handle );
1051     fprintf( stderr, " x=%d,", req->x );
1052     fprintf( stderr, " y=%d,", req->y );
1053     fprintf( stderr, " mode=%d,", req->mode );
1054     fprintf( stderr, " wrap=%d,", req->wrap );
1055     fprintf( stderr, " data=" );
1056     dump_varargs_bytes( cur_size );
1057 }
1058
1059 static void dump_write_console_output_reply( const struct write_console_output_reply *req )
1060 {
1061     fprintf( stderr, " written=%d,", req->written );
1062     fprintf( stderr, " width=%d,", req->width );
1063     fprintf( stderr, " height=%d", req->height );
1064 }
1065
1066 static void dump_fill_console_output_request( const struct fill_console_output_request *req )
1067 {
1068     fprintf( stderr, " handle=%d,", req->handle );
1069     fprintf( stderr, " x=%d,", req->x );
1070     fprintf( stderr, " y=%d,", req->y );
1071     fprintf( stderr, " mode=%d,", req->mode );
1072     fprintf( stderr, " count=%d,", req->count );
1073     fprintf( stderr, " wrap=%d,", req->wrap );
1074     fprintf( stderr, " data=" );
1075     dump_char_info( &req->data );
1076 }
1077
1078 static void dump_fill_console_output_reply( const struct fill_console_output_reply *req )
1079 {
1080     fprintf( stderr, " written=%d", req->written );
1081 }
1082
1083 static void dump_read_console_output_request( const struct read_console_output_request *req )
1084 {
1085     fprintf( stderr, " handle=%d,", req->handle );
1086     fprintf( stderr, " x=%d,", req->x );
1087     fprintf( stderr, " y=%d,", req->y );
1088     fprintf( stderr, " mode=%d,", req->mode );
1089     fprintf( stderr, " wrap=%d", req->wrap );
1090 }
1091
1092 static void dump_read_console_output_reply( const struct read_console_output_reply *req )
1093 {
1094     fprintf( stderr, " width=%d,", req->width );
1095     fprintf( stderr, " height=%d,", req->height );
1096     fprintf( stderr, " data=" );
1097     dump_varargs_bytes( cur_size );
1098 }
1099
1100 static void dump_move_console_output_request( const struct move_console_output_request *req )
1101 {
1102     fprintf( stderr, " handle=%d,", req->handle );
1103     fprintf( stderr, " x_src=%d,", req->x_src );
1104     fprintf( stderr, " y_src=%d,", req->y_src );
1105     fprintf( stderr, " x_dst=%d,", req->x_dst );
1106     fprintf( stderr, " y_dst=%d,", req->y_dst );
1107     fprintf( stderr, " w=%d,", req->w );
1108     fprintf( stderr, " h=%d", req->h );
1109 }
1110
1111 static void dump_create_change_notification_request( const struct create_change_notification_request *req )
1112 {
1113     fprintf( stderr, " subtree=%d,", req->subtree );
1114     fprintf( stderr, " filter=%d", req->filter );
1115 }
1116
1117 static void dump_create_change_notification_reply( const struct create_change_notification_reply *req )
1118 {
1119     fprintf( stderr, " handle=%d", req->handle );
1120 }
1121
1122 static void dump_create_mapping_request( const struct create_mapping_request *req )
1123 {
1124     fprintf( stderr, " size_high=%d,", req->size_high );
1125     fprintf( stderr, " size_low=%d,", req->size_low );
1126     fprintf( stderr, " protect=%d,", req->protect );
1127     fprintf( stderr, " inherit=%d,", req->inherit );
1128     fprintf( stderr, " file_handle=%d,", req->file_handle );
1129     fprintf( stderr, " name=" );
1130     dump_varargs_unicode_str( cur_size );
1131 }
1132
1133 static void dump_create_mapping_reply( const struct create_mapping_reply *req )
1134 {
1135     fprintf( stderr, " handle=%d", req->handle );
1136 }
1137
1138 static void dump_open_mapping_request( const struct open_mapping_request *req )
1139 {
1140     fprintf( stderr, " access=%08x,", req->access );
1141     fprintf( stderr, " inherit=%d,", req->inherit );
1142     fprintf( stderr, " name=" );
1143     dump_varargs_unicode_str( cur_size );
1144 }
1145
1146 static void dump_open_mapping_reply( const struct open_mapping_reply *req )
1147 {
1148     fprintf( stderr, " handle=%d", req->handle );
1149 }
1150
1151 static void dump_get_mapping_info_request( const struct get_mapping_info_request *req )
1152 {
1153     fprintf( stderr, " handle=%d", req->handle );
1154 }
1155
1156 static void dump_get_mapping_info_reply( const struct get_mapping_info_reply *req )
1157 {
1158     fprintf( stderr, " size_high=%d,", req->size_high );
1159     fprintf( stderr, " size_low=%d,", req->size_low );
1160     fprintf( stderr, " protect=%d,", req->protect );
1161     fprintf( stderr, " header_size=%d,", req->header_size );
1162     fprintf( stderr, " base=%p,", req->base );
1163     fprintf( stderr, " shared_file=%d,", req->shared_file );
1164     fprintf( stderr, " shared_size=%d,", req->shared_size );
1165     fprintf( stderr, " drive_type=%d", req->drive_type );
1166 }
1167
1168 static void dump_create_device_request( const struct create_device_request *req )
1169 {
1170     fprintf( stderr, " access=%08x,", req->access );
1171     fprintf( stderr, " inherit=%d,", req->inherit );
1172     fprintf( stderr, " id=%d", req->id );
1173 }
1174
1175 static void dump_create_device_reply( const struct create_device_reply *req )
1176 {
1177     fprintf( stderr, " handle=%d", req->handle );
1178 }
1179
1180 static void dump_create_snapshot_request( const struct create_snapshot_request *req )
1181 {
1182     fprintf( stderr, " inherit=%d,", req->inherit );
1183     fprintf( stderr, " flags=%d,", req->flags );
1184     fprintf( stderr, " pid=%p", req->pid );
1185 }
1186
1187 static void dump_create_snapshot_reply( const struct create_snapshot_reply *req )
1188 {
1189     fprintf( stderr, " handle=%d", req->handle );
1190 }
1191
1192 static void dump_next_process_request( const struct next_process_request *req )
1193 {
1194     fprintf( stderr, " handle=%d,", req->handle );
1195     fprintf( stderr, " reset=%d", req->reset );
1196 }
1197
1198 static void dump_next_process_reply( const struct next_process_reply *req )
1199 {
1200     fprintf( stderr, " count=%d,", req->count );
1201     fprintf( stderr, " pid=%p,", req->pid );
1202     fprintf( stderr, " threads=%d,", req->threads );
1203     fprintf( stderr, " priority=%d", req->priority );
1204 }
1205
1206 static void dump_next_thread_request( const struct next_thread_request *req )
1207 {
1208     fprintf( stderr, " handle=%d,", req->handle );
1209     fprintf( stderr, " reset=%d", req->reset );
1210 }
1211
1212 static void dump_next_thread_reply( const struct next_thread_reply *req )
1213 {
1214     fprintf( stderr, " count=%d,", req->count );
1215     fprintf( stderr, " pid=%p,", req->pid );
1216     fprintf( stderr, " tid=%p,", req->tid );
1217     fprintf( stderr, " base_pri=%d,", req->base_pri );
1218     fprintf( stderr, " delta_pri=%d", req->delta_pri );
1219 }
1220
1221 static void dump_next_module_request( const struct next_module_request *req )
1222 {
1223     fprintf( stderr, " handle=%d,", req->handle );
1224     fprintf( stderr, " reset=%d", req->reset );
1225 }
1226
1227 static void dump_next_module_reply( const struct next_module_reply *req )
1228 {
1229     fprintf( stderr, " pid=%p,", req->pid );
1230     fprintf( stderr, " base=%p", req->base );
1231 }
1232
1233 static void dump_wait_debug_event_request( const struct wait_debug_event_request *req )
1234 {
1235     fprintf( stderr, " get_handle=%d", req->get_handle );
1236 }
1237
1238 static void dump_wait_debug_event_reply( const struct wait_debug_event_reply *req )
1239 {
1240     fprintf( stderr, " pid=%p,", req->pid );
1241     fprintf( stderr, " tid=%p,", req->tid );
1242     fprintf( stderr, " wait=%d,", req->wait );
1243     fprintf( stderr, " event=" );
1244     dump_varargs_debug_event( cur_size );
1245 }
1246
1247 static void dump_queue_exception_event_request( const struct queue_exception_event_request *req )
1248 {
1249     fprintf( stderr, " first=%d,", req->first );
1250     fprintf( stderr, " record=" );
1251     dump_varargs_exc_event( cur_size );
1252 }
1253
1254 static void dump_queue_exception_event_reply( const struct queue_exception_event_reply *req )
1255 {
1256     fprintf( stderr, " handle=%d", req->handle );
1257 }
1258
1259 static void dump_get_exception_status_request( const struct get_exception_status_request *req )
1260 {
1261     fprintf( stderr, " handle=%d", req->handle );
1262 }
1263
1264 static void dump_get_exception_status_reply( const struct get_exception_status_reply *req )
1265 {
1266     fprintf( stderr, " status=%d,", req->status );
1267     fprintf( stderr, " context=" );
1268     dump_varargs_context( cur_size );
1269 }
1270
1271 static void dump_output_debug_string_request( const struct output_debug_string_request *req )
1272 {
1273     fprintf( stderr, " string=%p,", req->string );
1274     fprintf( stderr, " unicode=%d,", req->unicode );
1275     fprintf( stderr, " length=%d", req->length );
1276 }
1277
1278 static void dump_continue_debug_event_request( const struct continue_debug_event_request *req )
1279 {
1280     fprintf( stderr, " pid=%p,", req->pid );
1281     fprintf( stderr, " tid=%p,", req->tid );
1282     fprintf( stderr, " status=%d", req->status );
1283 }
1284
1285 static void dump_debug_process_request( const struct debug_process_request *req )
1286 {
1287     fprintf( stderr, " pid=%p", req->pid );
1288 }
1289
1290 static void dump_read_process_memory_request( const struct read_process_memory_request *req )
1291 {
1292     fprintf( stderr, " handle=%d,", req->handle );
1293     fprintf( stderr, " addr=%p", req->addr );
1294 }
1295
1296 static void dump_read_process_memory_reply( const struct read_process_memory_reply *req )
1297 {
1298     fprintf( stderr, " data=" );
1299     dump_varargs_bytes( cur_size );
1300 }
1301
1302 static void dump_write_process_memory_request( const struct write_process_memory_request *req )
1303 {
1304     fprintf( stderr, " handle=%d,", req->handle );
1305     fprintf( stderr, " addr=%p,", req->addr );
1306     fprintf( stderr, " first_mask=%08x,", req->first_mask );
1307     fprintf( stderr, " last_mask=%08x,", req->last_mask );
1308     fprintf( stderr, " data=" );
1309     dump_varargs_bytes( cur_size );
1310 }
1311
1312 static void dump_create_key_request( const struct create_key_request *req )
1313 {
1314     fprintf( stderr, " parent=%d,", req->parent );
1315     fprintf( stderr, " access=%08x,", req->access );
1316     fprintf( stderr, " options=%08x,", req->options );
1317     fprintf( stderr, " modif=%ld,", req->modif );
1318     fprintf( stderr, " namelen=%d,", req->namelen );
1319     fprintf( stderr, " name=" );
1320     dump_varargs_unicode_str( min(cur_size,req->namelen) );
1321     fputc( ',', stderr );
1322     fprintf( stderr, " class=" );
1323     dump_varargs_unicode_str( cur_size );
1324 }
1325
1326 static void dump_create_key_reply( const struct create_key_reply *req )
1327 {
1328     fprintf( stderr, " hkey=%d,", req->hkey );
1329     fprintf( stderr, " created=%d", req->created );
1330 }
1331
1332 static void dump_open_key_request( const struct open_key_request *req )
1333 {
1334     fprintf( stderr, " parent=%d,", req->parent );
1335     fprintf( stderr, " access=%08x,", req->access );
1336     fprintf( stderr, " name=" );
1337     dump_varargs_unicode_str( cur_size );
1338 }
1339
1340 static void dump_open_key_reply( const struct open_key_reply *req )
1341 {
1342     fprintf( stderr, " hkey=%d", req->hkey );
1343 }
1344
1345 static void dump_delete_key_request( const struct delete_key_request *req )
1346 {
1347     fprintf( stderr, " hkey=%d", req->hkey );
1348 }
1349
1350 static void dump_enum_key_request( const struct enum_key_request *req )
1351 {
1352     fprintf( stderr, " hkey=%d,", req->hkey );
1353     fprintf( stderr, " index=%d,", req->index );
1354     fprintf( stderr, " info_class=%d", req->info_class );
1355 }
1356
1357 static void dump_enum_key_reply( const struct enum_key_reply *req )
1358 {
1359     fprintf( stderr, " subkeys=%d,", req->subkeys );
1360     fprintf( stderr, " max_subkey=%d,", req->max_subkey );
1361     fprintf( stderr, " max_class=%d,", req->max_class );
1362     fprintf( stderr, " values=%d,", req->values );
1363     fprintf( stderr, " max_value=%d,", req->max_value );
1364     fprintf( stderr, " max_data=%d,", req->max_data );
1365     fprintf( stderr, " modif=%ld,", req->modif );
1366     fprintf( stderr, " total=%d,", req->total );
1367     fprintf( stderr, " namelen=%d,", req->namelen );
1368     fprintf( stderr, " name=" );
1369     dump_varargs_unicode_str( min(cur_size,req->namelen) );
1370     fputc( ',', stderr );
1371     fprintf( stderr, " class=" );
1372     dump_varargs_unicode_str( cur_size );
1373 }
1374
1375 static void dump_set_key_value_request( const struct set_key_value_request *req )
1376 {
1377     fprintf( stderr, " hkey=%d,", req->hkey );
1378     fprintf( stderr, " type=%d,", req->type );
1379     fprintf( stderr, " namelen=%d,", req->namelen );
1380     fprintf( stderr, " name=" );
1381     dump_varargs_unicode_str( min(cur_size,req->namelen) );
1382     fputc( ',', stderr );
1383     fprintf( stderr, " data=" );
1384     dump_varargs_bytes( cur_size );
1385 }
1386
1387 static void dump_get_key_value_request( const struct get_key_value_request *req )
1388 {
1389     fprintf( stderr, " hkey=%d,", req->hkey );
1390     fprintf( stderr, " name=" );
1391     dump_varargs_unicode_str( cur_size );
1392 }
1393
1394 static void dump_get_key_value_reply( const struct get_key_value_reply *req )
1395 {
1396     fprintf( stderr, " type=%d,", req->type );
1397     fprintf( stderr, " total=%d,", req->total );
1398     fprintf( stderr, " data=" );
1399     dump_varargs_bytes( cur_size );
1400 }
1401
1402 static void dump_enum_key_value_request( const struct enum_key_value_request *req )
1403 {
1404     fprintf( stderr, " hkey=%d,", req->hkey );
1405     fprintf( stderr, " index=%d,", req->index );
1406     fprintf( stderr, " info_class=%d", req->info_class );
1407 }
1408
1409 static void dump_enum_key_value_reply( const struct enum_key_value_reply *req )
1410 {
1411     fprintf( stderr, " type=%d,", req->type );
1412     fprintf( stderr, " total=%d,", req->total );
1413     fprintf( stderr, " namelen=%d,", req->namelen );
1414     fprintf( stderr, " name=" );
1415     dump_varargs_unicode_str( min(cur_size,req->namelen) );
1416     fputc( ',', stderr );
1417     fprintf( stderr, " data=" );
1418     dump_varargs_bytes( cur_size );
1419 }
1420
1421 static void dump_delete_key_value_request( const struct delete_key_value_request *req )
1422 {
1423     fprintf( stderr, " hkey=%d,", req->hkey );
1424     fprintf( stderr, " name=" );
1425     dump_varargs_unicode_str( cur_size );
1426 }
1427
1428 static void dump_load_registry_request( const struct load_registry_request *req )
1429 {
1430     fprintf( stderr, " hkey=%d,", req->hkey );
1431     fprintf( stderr, " file=%d,", req->file );
1432     fprintf( stderr, " name=" );
1433     dump_varargs_unicode_str( cur_size );
1434 }
1435
1436 static void dump_save_registry_request( const struct save_registry_request *req )
1437 {
1438     fprintf( stderr, " hkey=%d,", req->hkey );
1439     fprintf( stderr, " file=%d", req->file );
1440 }
1441
1442 static void dump_save_registry_atexit_request( const struct save_registry_atexit_request *req )
1443 {
1444     fprintf( stderr, " hkey=%d,", req->hkey );
1445     fprintf( stderr, " file=" );
1446     dump_varargs_string( cur_size );
1447 }
1448
1449 static void dump_set_registry_levels_request( const struct set_registry_levels_request *req )
1450 {
1451     fprintf( stderr, " current=%d,", req->current );
1452     fprintf( stderr, " saving=%d,", req->saving );
1453     fprintf( stderr, " period=%d", req->period );
1454 }
1455
1456 static void dump_create_timer_request( const struct create_timer_request *req )
1457 {
1458     fprintf( stderr, " inherit=%d,", req->inherit );
1459     fprintf( stderr, " manual=%d,", req->manual );
1460     fprintf( stderr, " name=" );
1461     dump_varargs_unicode_str( cur_size );
1462 }
1463
1464 static void dump_create_timer_reply( const struct create_timer_reply *req )
1465 {
1466     fprintf( stderr, " handle=%d", req->handle );
1467 }
1468
1469 static void dump_open_timer_request( const struct open_timer_request *req )
1470 {
1471     fprintf( stderr, " access=%08x,", req->access );
1472     fprintf( stderr, " inherit=%d,", req->inherit );
1473     fprintf( stderr, " name=" );
1474     dump_varargs_unicode_str( cur_size );
1475 }
1476
1477 static void dump_open_timer_reply( const struct open_timer_reply *req )
1478 {
1479     fprintf( stderr, " handle=%d", req->handle );
1480 }
1481
1482 static void dump_set_timer_request( const struct set_timer_request *req )
1483 {
1484     fprintf( stderr, " handle=%d,", req->handle );
1485     fprintf( stderr, " sec=%d,", req->sec );
1486     fprintf( stderr, " usec=%d,", req->usec );
1487     fprintf( stderr, " period=%d,", req->period );
1488     fprintf( stderr, " callback=%p,", req->callback );
1489     fprintf( stderr, " arg=%p", req->arg );
1490 }
1491
1492 static void dump_cancel_timer_request( const struct cancel_timer_request *req )
1493 {
1494     fprintf( stderr, " handle=%d", req->handle );
1495 }
1496
1497 static void dump_get_thread_context_request( const struct get_thread_context_request *req )
1498 {
1499     fprintf( stderr, " handle=%d,", req->handle );
1500     fprintf( stderr, " flags=%08x", req->flags );
1501 }
1502
1503 static void dump_get_thread_context_reply( const struct get_thread_context_reply *req )
1504 {
1505     fprintf( stderr, " context=" );
1506     dump_varargs_context( cur_size );
1507 }
1508
1509 static void dump_set_thread_context_request( const struct set_thread_context_request *req )
1510 {
1511     fprintf( stderr, " handle=%d,", req->handle );
1512     fprintf( stderr, " flags=%08x,", req->flags );
1513     fprintf( stderr, " context=" );
1514     dump_varargs_context( cur_size );
1515 }
1516
1517 static void dump_get_selector_entry_request( const struct get_selector_entry_request *req )
1518 {
1519     fprintf( stderr, " handle=%d,", req->handle );
1520     fprintf( stderr, " entry=%d", req->entry );
1521 }
1522
1523 static void dump_get_selector_entry_reply( const struct get_selector_entry_reply *req )
1524 {
1525     fprintf( stderr, " base=%08x,", req->base );
1526     fprintf( stderr, " limit=%08x,", req->limit );
1527     fprintf( stderr, " flags=%02x", req->flags );
1528 }
1529
1530 static void dump_add_atom_request( const struct add_atom_request *req )
1531 {
1532     fprintf( stderr, " local=%d,", req->local );
1533     fprintf( stderr, " name=" );
1534     dump_varargs_unicode_str( cur_size );
1535 }
1536
1537 static void dump_add_atom_reply( const struct add_atom_reply *req )
1538 {
1539     fprintf( stderr, " atom=%04x", req->atom );
1540 }
1541
1542 static void dump_delete_atom_request( const struct delete_atom_request *req )
1543 {
1544     fprintf( stderr, " atom=%04x,", req->atom );
1545     fprintf( stderr, " local=%d", req->local );
1546 }
1547
1548 static void dump_find_atom_request( const struct find_atom_request *req )
1549 {
1550     fprintf( stderr, " local=%d,", req->local );
1551     fprintf( stderr, " name=" );
1552     dump_varargs_unicode_str( cur_size );
1553 }
1554
1555 static void dump_find_atom_reply( const struct find_atom_reply *req )
1556 {
1557     fprintf( stderr, " atom=%04x", req->atom );
1558 }
1559
1560 static void dump_get_atom_name_request( const struct get_atom_name_request *req )
1561 {
1562     fprintf( stderr, " atom=%04x,", req->atom );
1563     fprintf( stderr, " local=%d", req->local );
1564 }
1565
1566 static void dump_get_atom_name_reply( const struct get_atom_name_reply *req )
1567 {
1568     fprintf( stderr, " count=%d,", req->count );
1569     fprintf( stderr, " name=" );
1570     dump_varargs_unicode_str( cur_size );
1571 }
1572
1573 static void dump_init_atom_table_request( const struct init_atom_table_request *req )
1574 {
1575     fprintf( stderr, " entries=%d", req->entries );
1576 }
1577
1578 static void dump_get_msg_queue_request( const struct get_msg_queue_request *req )
1579 {
1580 }
1581
1582 static void dump_get_msg_queue_reply( const struct get_msg_queue_reply *req )
1583 {
1584     fprintf( stderr, " handle=%d", req->handle );
1585 }
1586
1587 static void dump_set_queue_mask_request( const struct set_queue_mask_request *req )
1588 {
1589     fprintf( stderr, " wake_mask=%08x,", req->wake_mask );
1590     fprintf( stderr, " changed_mask=%08x,", req->changed_mask );
1591     fprintf( stderr, " skip_wait=%d", req->skip_wait );
1592 }
1593
1594 static void dump_set_queue_mask_reply( const struct set_queue_mask_reply *req )
1595 {
1596     fprintf( stderr, " wake_bits=%08x,", req->wake_bits );
1597     fprintf( stderr, " changed_bits=%08x", req->changed_bits );
1598 }
1599
1600 static void dump_get_queue_status_request( const struct get_queue_status_request *req )
1601 {
1602     fprintf( stderr, " clear=%d", req->clear );
1603 }
1604
1605 static void dump_get_queue_status_reply( const struct get_queue_status_reply *req )
1606 {
1607     fprintf( stderr, " wake_bits=%08x,", req->wake_bits );
1608     fprintf( stderr, " changed_bits=%08x", req->changed_bits );
1609 }
1610
1611 static void dump_wait_input_idle_request( const struct wait_input_idle_request *req )
1612 {
1613     fprintf( stderr, " handle=%d,", req->handle );
1614     fprintf( stderr, " timeout=%d", req->timeout );
1615 }
1616
1617 static void dump_wait_input_idle_reply( const struct wait_input_idle_reply *req )
1618 {
1619     fprintf( stderr, " event=%d", req->event );
1620 }
1621
1622 static void dump_send_message_request( const struct send_message_request *req )
1623 {
1624     fprintf( stderr, " id=%p,", req->id );
1625     fprintf( stderr, " type=%d,", req->type );
1626     fprintf( stderr, " win=%08x,", req->win );
1627     fprintf( stderr, " msg=%08x,", req->msg );
1628     fprintf( stderr, " wparam=%08x,", req->wparam );
1629     fprintf( stderr, " lparam=%08x,", req->lparam );
1630     fprintf( stderr, " x=%d,", req->x );
1631     fprintf( stderr, " y=%d,", req->y );
1632     fprintf( stderr, " time=%08x,", req->time );
1633     fprintf( stderr, " info=%08x,", req->info );
1634     fprintf( stderr, " timeout=%d,", req->timeout );
1635     fprintf( stderr, " data=" );
1636     dump_varargs_bytes( cur_size );
1637 }
1638
1639 static void dump_get_message_request( const struct get_message_request *req )
1640 {
1641     fprintf( stderr, " flags=%d,", req->flags );
1642     fprintf( stderr, " get_win=%08x,", req->get_win );
1643     fprintf( stderr, " get_first=%08x,", req->get_first );
1644     fprintf( stderr, " get_last=%08x", req->get_last );
1645 }
1646
1647 static void dump_get_message_reply( const struct get_message_reply *req )
1648 {
1649     fprintf( stderr, " type=%d,", req->type );
1650     fprintf( stderr, " win=%08x,", req->win );
1651     fprintf( stderr, " msg=%08x,", req->msg );
1652     fprintf( stderr, " wparam=%08x,", req->wparam );
1653     fprintf( stderr, " lparam=%08x,", req->lparam );
1654     fprintf( stderr, " x=%d,", req->x );
1655     fprintf( stderr, " y=%d,", req->y );
1656     fprintf( stderr, " time=%08x,", req->time );
1657     fprintf( stderr, " info=%08x,", req->info );
1658     fprintf( stderr, " total=%d,", req->total );
1659     fprintf( stderr, " data=" );
1660     dump_varargs_bytes( cur_size );
1661 }
1662
1663 static void dump_reply_message_request( const struct reply_message_request *req )
1664 {
1665     fprintf( stderr, " result=%08x,", req->result );
1666     fprintf( stderr, " remove=%d,", req->remove );
1667     fprintf( stderr, " data=" );
1668     dump_varargs_bytes( cur_size );
1669 }
1670
1671 static void dump_get_message_reply_request( const struct get_message_reply_request *req )
1672 {
1673     fprintf( stderr, " cancel=%d", req->cancel );
1674 }
1675
1676 static void dump_get_message_reply_reply( const struct get_message_reply_reply *req )
1677 {
1678     fprintf( stderr, " result=%08x,", req->result );
1679     fprintf( stderr, " data=" );
1680     dump_varargs_bytes( cur_size );
1681 }
1682
1683 static void dump_set_win_timer_request( const struct set_win_timer_request *req )
1684 {
1685     fprintf( stderr, " win=%08x,", req->win );
1686     fprintf( stderr, " msg=%08x,", req->msg );
1687     fprintf( stderr, " id=%08x,", req->id );
1688     fprintf( stderr, " rate=%08x,", req->rate );
1689     fprintf( stderr, " lparam=%08x", req->lparam );
1690 }
1691
1692 static void dump_kill_win_timer_request( const struct kill_win_timer_request *req )
1693 {
1694     fprintf( stderr, " win=%08x,", req->win );
1695     fprintf( stderr, " msg=%08x,", req->msg );
1696     fprintf( stderr, " id=%08x", req->id );
1697 }
1698
1699 static void dump_create_serial_request( const struct create_serial_request *req )
1700 {
1701     fprintf( stderr, " access=%08x,", req->access );
1702     fprintf( stderr, " inherit=%d,", req->inherit );
1703     fprintf( stderr, " attributes=%08x,", req->attributes );
1704     fprintf( stderr, " sharing=%08x,", req->sharing );
1705     fprintf( stderr, " name=" );
1706     dump_varargs_string( cur_size );
1707 }
1708
1709 static void dump_create_serial_reply( const struct create_serial_reply *req )
1710 {
1711     fprintf( stderr, " handle=%d", req->handle );
1712 }
1713
1714 static void dump_get_serial_info_request( const struct get_serial_info_request *req )
1715 {
1716     fprintf( stderr, " handle=%d", req->handle );
1717 }
1718
1719 static void dump_get_serial_info_reply( const struct get_serial_info_reply *req )
1720 {
1721     fprintf( stderr, " readinterval=%08x,", req->readinterval );
1722     fprintf( stderr, " readconst=%08x,", req->readconst );
1723     fprintf( stderr, " readmult=%08x,", req->readmult );
1724     fprintf( stderr, " writeconst=%08x,", req->writeconst );
1725     fprintf( stderr, " writemult=%08x,", req->writemult );
1726     fprintf( stderr, " eventmask=%08x,", req->eventmask );
1727     fprintf( stderr, " commerror=%08x", req->commerror );
1728 }
1729
1730 static void dump_set_serial_info_request( const struct set_serial_info_request *req )
1731 {
1732     fprintf( stderr, " handle=%d,", req->handle );
1733     fprintf( stderr, " flags=%d,", req->flags );
1734     fprintf( stderr, " readinterval=%08x,", req->readinterval );
1735     fprintf( stderr, " readconst=%08x,", req->readconst );
1736     fprintf( stderr, " readmult=%08x,", req->readmult );
1737     fprintf( stderr, " writeconst=%08x,", req->writeconst );
1738     fprintf( stderr, " writemult=%08x,", req->writemult );
1739     fprintf( stderr, " eventmask=%08x,", req->eventmask );
1740     fprintf( stderr, " commerror=%08x", req->commerror );
1741 }
1742
1743 static void dump_register_async_request( const struct register_async_request *req )
1744 {
1745     fprintf( stderr, " handle=%d,", req->handle );
1746     fprintf( stderr, " func=%p,", req->func );
1747     fprintf( stderr, " type=%d,", req->type );
1748     fprintf( stderr, " overlapped=%p,", req->overlapped );
1749     fprintf( stderr, " count=%d,", req->count );
1750     fprintf( stderr, " status=%08x", req->status );
1751 }
1752
1753 static void dump_create_named_pipe_request( const struct create_named_pipe_request *req )
1754 {
1755     fprintf( stderr, " openmode=%08x,", req->openmode );
1756     fprintf( stderr, " pipemode=%08x,", req->pipemode );
1757     fprintf( stderr, " maxinstances=%08x,", req->maxinstances );
1758     fprintf( stderr, " outsize=%08x,", req->outsize );
1759     fprintf( stderr, " insize=%08x,", req->insize );
1760     fprintf( stderr, " timeout=%08x,", req->timeout );
1761     fprintf( stderr, " name=" );
1762     dump_varargs_unicode_str( cur_size );
1763 }
1764
1765 static void dump_create_named_pipe_reply( const struct create_named_pipe_reply *req )
1766 {
1767     fprintf( stderr, " handle=%d", req->handle );
1768 }
1769
1770 static void dump_open_named_pipe_request( const struct open_named_pipe_request *req )
1771 {
1772     fprintf( stderr, " access=%08x,", req->access );
1773     fprintf( stderr, " name=" );
1774     dump_varargs_unicode_str( cur_size );
1775 }
1776
1777 static void dump_open_named_pipe_reply( const struct open_named_pipe_reply *req )
1778 {
1779     fprintf( stderr, " handle=%d", req->handle );
1780 }
1781
1782 static void dump_connect_named_pipe_request( const struct connect_named_pipe_request *req )
1783 {
1784     fprintf( stderr, " handle=%d,", req->handle );
1785     fprintf( stderr, " overlapped=%p,", req->overlapped );
1786     fprintf( stderr, " func=%p", req->func );
1787 }
1788
1789 static void dump_wait_named_pipe_request( const struct wait_named_pipe_request *req )
1790 {
1791     fprintf( stderr, " timeout=%08x,", req->timeout );
1792     fprintf( stderr, " overlapped=%p,", req->overlapped );
1793     fprintf( stderr, " func=%p,", req->func );
1794     fprintf( stderr, " name=" );
1795     dump_varargs_unicode_str( cur_size );
1796 }
1797
1798 static void dump_disconnect_named_pipe_request( const struct disconnect_named_pipe_request *req )
1799 {
1800     fprintf( stderr, " handle=%d", req->handle );
1801 }
1802
1803 static void dump_get_named_pipe_info_request( const struct get_named_pipe_info_request *req )
1804 {
1805     fprintf( stderr, " handle=%d", req->handle );
1806 }
1807
1808 static void dump_get_named_pipe_info_reply( const struct get_named_pipe_info_reply *req )
1809 {
1810     fprintf( stderr, " flags=%08x,", req->flags );
1811     fprintf( stderr, " maxinstances=%08x,", req->maxinstances );
1812     fprintf( stderr, " outsize=%08x,", req->outsize );
1813     fprintf( stderr, " insize=%08x", req->insize );
1814 }
1815
1816 static void dump_create_window_request( const struct create_window_request *req )
1817 {
1818     fprintf( stderr, " parent=%08x,", req->parent );
1819     fprintf( stderr, " owner=%08x,", req->owner );
1820     fprintf( stderr, " atom=%04x", req->atom );
1821 }
1822
1823 static void dump_create_window_reply( const struct create_window_reply *req )
1824 {
1825     fprintf( stderr, " handle=%08x", req->handle );
1826 }
1827
1828 static void dump_link_window_request( const struct link_window_request *req )
1829 {
1830     fprintf( stderr, " handle=%08x,", req->handle );
1831     fprintf( stderr, " parent=%08x,", req->parent );
1832     fprintf( stderr, " previous=%08x", req->previous );
1833 }
1834
1835 static void dump_link_window_reply( const struct link_window_reply *req )
1836 {
1837     fprintf( stderr, " full_parent=%08x", req->full_parent );
1838 }
1839
1840 static void dump_destroy_window_request( const struct destroy_window_request *req )
1841 {
1842     fprintf( stderr, " handle=%08x", req->handle );
1843 }
1844
1845 static void dump_set_window_owner_request( const struct set_window_owner_request *req )
1846 {
1847     fprintf( stderr, " handle=%08x,", req->handle );
1848     fprintf( stderr, " owner=%08x", req->owner );
1849 }
1850
1851 static void dump_set_window_owner_reply( const struct set_window_owner_reply *req )
1852 {
1853     fprintf( stderr, " full_owner=%08x", req->full_owner );
1854 }
1855
1856 static void dump_get_window_info_request( const struct get_window_info_request *req )
1857 {
1858     fprintf( stderr, " handle=%08x", req->handle );
1859 }
1860
1861 static void dump_get_window_info_reply( const struct get_window_info_reply *req )
1862 {
1863     fprintf( stderr, " full_handle=%08x,", req->full_handle );
1864     fprintf( stderr, " pid=%p,", req->pid );
1865     fprintf( stderr, " tid=%p,", req->tid );
1866     fprintf( stderr, " atom=%04x", req->atom );
1867 }
1868
1869 static void dump_set_window_info_request( const struct set_window_info_request *req )
1870 {
1871     fprintf( stderr, " handle=%08x,", req->handle );
1872     fprintf( stderr, " flags=%08x,", req->flags );
1873     fprintf( stderr, " style=%08x,", req->style );
1874     fprintf( stderr, " ex_style=%08x,", req->ex_style );
1875     fprintf( stderr, " id=%08x,", req->id );
1876     fprintf( stderr, " instance=%p,", req->instance );
1877     fprintf( stderr, " user_data=%p", req->user_data );
1878 }
1879
1880 static void dump_set_window_info_reply( const struct set_window_info_reply *req )
1881 {
1882     fprintf( stderr, " old_style=%08x,", req->old_style );
1883     fprintf( stderr, " old_ex_style=%08x,", req->old_ex_style );
1884     fprintf( stderr, " old_id=%08x,", req->old_id );
1885     fprintf( stderr, " old_instance=%p,", req->old_instance );
1886     fprintf( stderr, " old_user_data=%p", req->old_user_data );
1887 }
1888
1889 static void dump_get_window_parents_request( const struct get_window_parents_request *req )
1890 {
1891     fprintf( stderr, " handle=%08x", req->handle );
1892 }
1893
1894 static void dump_get_window_parents_reply( const struct get_window_parents_reply *req )
1895 {
1896     fprintf( stderr, " count=%d,", req->count );
1897     fprintf( stderr, " parents=" );
1898     dump_varargs_user_handles( cur_size );
1899 }
1900
1901 static void dump_get_window_children_request( const struct get_window_children_request *req )
1902 {
1903     fprintf( stderr, " parent=%08x,", req->parent );
1904     fprintf( stderr, " atom=%04x,", req->atom );
1905     fprintf( stderr, " tid=%p", req->tid );
1906 }
1907
1908 static void dump_get_window_children_reply( const struct get_window_children_reply *req )
1909 {
1910     fprintf( stderr, " count=%d,", req->count );
1911     fprintf( stderr, " children=" );
1912     dump_varargs_user_handles( cur_size );
1913 }
1914
1915 static void dump_get_window_tree_request( const struct get_window_tree_request *req )
1916 {
1917     fprintf( stderr, " handle=%08x", req->handle );
1918 }
1919
1920 static void dump_get_window_tree_reply( const struct get_window_tree_reply *req )
1921 {
1922     fprintf( stderr, " parent=%08x,", req->parent );
1923     fprintf( stderr, " owner=%08x,", req->owner );
1924     fprintf( stderr, " next_sibling=%08x,", req->next_sibling );
1925     fprintf( stderr, " prev_sibling=%08x,", req->prev_sibling );
1926     fprintf( stderr, " first_sibling=%08x,", req->first_sibling );
1927     fprintf( stderr, " last_sibling=%08x,", req->last_sibling );
1928     fprintf( stderr, " first_child=%08x,", req->first_child );
1929     fprintf( stderr, " last_child=%08x", req->last_child );
1930 }
1931
1932 static void dump_set_window_rectangles_request( const struct set_window_rectangles_request *req )
1933 {
1934     fprintf( stderr, " handle=%08x,", req->handle );
1935     fprintf( stderr, " window=" );
1936     dump_rectangle( &req->window );
1937     fprintf( stderr, "," );
1938     fprintf( stderr, " client=" );
1939     dump_rectangle( &req->client );
1940 }
1941
1942 static void dump_get_window_rectangles_request( const struct get_window_rectangles_request *req )
1943 {
1944     fprintf( stderr, " handle=%08x", req->handle );
1945 }
1946
1947 static void dump_get_window_rectangles_reply( const struct get_window_rectangles_reply *req )
1948 {
1949     fprintf( stderr, " window=" );
1950     dump_rectangle( &req->window );
1951     fprintf( stderr, "," );
1952     fprintf( stderr, " client=" );
1953     dump_rectangle( &req->client );
1954 }
1955
1956 static void dump_get_window_text_request( const struct get_window_text_request *req )
1957 {
1958     fprintf( stderr, " handle=%08x", req->handle );
1959 }
1960
1961 static void dump_get_window_text_reply( const struct get_window_text_reply *req )
1962 {
1963     fprintf( stderr, " text=" );
1964     dump_varargs_unicode_str( cur_size );
1965 }
1966
1967 static void dump_set_window_text_request( const struct set_window_text_request *req )
1968 {
1969     fprintf( stderr, " handle=%08x,", req->handle );
1970     fprintf( stderr, " text=" );
1971     dump_varargs_unicode_str( cur_size );
1972 }
1973
1974 static void dump_inc_window_paint_count_request( const struct inc_window_paint_count_request *req )
1975 {
1976     fprintf( stderr, " handle=%08x,", req->handle );
1977     fprintf( stderr, " incr=%d", req->incr );
1978 }
1979
1980 static void dump_get_windows_offset_request( const struct get_windows_offset_request *req )
1981 {
1982     fprintf( stderr, " from=%08x,", req->from );
1983     fprintf( stderr, " to=%08x", req->to );
1984 }
1985
1986 static void dump_get_windows_offset_reply( const struct get_windows_offset_reply *req )
1987 {
1988     fprintf( stderr, " x=%d,", req->x );
1989     fprintf( stderr, " y=%d", req->y );
1990 }
1991
1992 static void dump_set_window_property_request( const struct set_window_property_request *req )
1993 {
1994     fprintf( stderr, " window=%08x,", req->window );
1995     fprintf( stderr, " atom=%04x,", req->atom );
1996     fprintf( stderr, " string=%d,", req->string );
1997     fprintf( stderr, " handle=%d", req->handle );
1998 }
1999
2000 static void dump_remove_window_property_request( const struct remove_window_property_request *req )
2001 {
2002     fprintf( stderr, " window=%08x,", req->window );
2003     fprintf( stderr, " atom=%04x", req->atom );
2004 }
2005
2006 static void dump_remove_window_property_reply( const struct remove_window_property_reply *req )
2007 {
2008     fprintf( stderr, " handle=%d", req->handle );
2009 }
2010
2011 static void dump_get_window_property_request( const struct get_window_property_request *req )
2012 {
2013     fprintf( stderr, " window=%08x,", req->window );
2014     fprintf( stderr, " atom=%04x", req->atom );
2015 }
2016
2017 static void dump_get_window_property_reply( const struct get_window_property_reply *req )
2018 {
2019     fprintf( stderr, " handle=%d", req->handle );
2020 }
2021
2022 static void dump_get_window_properties_request( const struct get_window_properties_request *req )
2023 {
2024     fprintf( stderr, " window=%08x", req->window );
2025 }
2026
2027 static void dump_get_window_properties_reply( const struct get_window_properties_reply *req )
2028 {
2029     fprintf( stderr, " total=%d,", req->total );
2030     fprintf( stderr, " props=" );
2031     dump_varargs_properties( cur_size );
2032 }
2033
2034 static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
2035     (dump_func)dump_new_process_request,
2036     (dump_func)dump_get_new_process_info_request,
2037     (dump_func)dump_new_thread_request,
2038     (dump_func)dump_boot_done_request,
2039     (dump_func)dump_init_process_request,
2040     (dump_func)dump_init_process_done_request,
2041     (dump_func)dump_init_thread_request,
2042     (dump_func)dump_terminate_process_request,
2043     (dump_func)dump_terminate_thread_request,
2044     (dump_func)dump_get_process_info_request,
2045     (dump_func)dump_set_process_info_request,
2046     (dump_func)dump_get_thread_info_request,
2047     (dump_func)dump_set_thread_info_request,
2048     (dump_func)dump_suspend_thread_request,
2049     (dump_func)dump_resume_thread_request,
2050     (dump_func)dump_load_dll_request,
2051     (dump_func)dump_unload_dll_request,
2052     (dump_func)dump_queue_apc_request,
2053     (dump_func)dump_get_apc_request,
2054     (dump_func)dump_close_handle_request,
2055     (dump_func)dump_set_handle_info_request,
2056     (dump_func)dump_dup_handle_request,
2057     (dump_func)dump_open_process_request,
2058     (dump_func)dump_select_request,
2059     (dump_func)dump_create_event_request,
2060     (dump_func)dump_event_op_request,
2061     (dump_func)dump_open_event_request,
2062     (dump_func)dump_create_mutex_request,
2063     (dump_func)dump_release_mutex_request,
2064     (dump_func)dump_open_mutex_request,
2065     (dump_func)dump_create_semaphore_request,
2066     (dump_func)dump_release_semaphore_request,
2067     (dump_func)dump_open_semaphore_request,
2068     (dump_func)dump_create_file_request,
2069     (dump_func)dump_alloc_file_handle_request,
2070     (dump_func)dump_get_handle_fd_request,
2071     (dump_func)dump_set_file_pointer_request,
2072     (dump_func)dump_truncate_file_request,
2073     (dump_func)dump_set_file_time_request,
2074     (dump_func)dump_flush_file_request,
2075     (dump_func)dump_get_file_info_request,
2076     (dump_func)dump_lock_file_request,
2077     (dump_func)dump_unlock_file_request,
2078     (dump_func)dump_create_pipe_request,
2079     (dump_func)dump_create_socket_request,
2080     (dump_func)dump_accept_socket_request,
2081     (dump_func)dump_set_socket_event_request,
2082     (dump_func)dump_get_socket_event_request,
2083     (dump_func)dump_enable_socket_event_request,
2084     (dump_func)dump_alloc_console_request,
2085     (dump_func)dump_free_console_request,
2086     (dump_func)dump_get_console_renderer_events_request,
2087     (dump_func)dump_open_console_request,
2088     (dump_func)dump_get_console_mode_request,
2089     (dump_func)dump_set_console_mode_request,
2090     (dump_func)dump_set_console_input_info_request,
2091     (dump_func)dump_get_console_input_info_request,
2092     (dump_func)dump_append_console_input_history_request,
2093     (dump_func)dump_get_console_input_history_request,
2094     (dump_func)dump_create_console_output_request,
2095     (dump_func)dump_set_console_output_info_request,
2096     (dump_func)dump_get_console_output_info_request,
2097     (dump_func)dump_write_console_input_request,
2098     (dump_func)dump_read_console_input_request,
2099     (dump_func)dump_write_console_output_request,
2100     (dump_func)dump_fill_console_output_request,
2101     (dump_func)dump_read_console_output_request,
2102     (dump_func)dump_move_console_output_request,
2103     (dump_func)dump_create_change_notification_request,
2104     (dump_func)dump_create_mapping_request,
2105     (dump_func)dump_open_mapping_request,
2106     (dump_func)dump_get_mapping_info_request,
2107     (dump_func)dump_create_device_request,
2108     (dump_func)dump_create_snapshot_request,
2109     (dump_func)dump_next_process_request,
2110     (dump_func)dump_next_thread_request,
2111     (dump_func)dump_next_module_request,
2112     (dump_func)dump_wait_debug_event_request,
2113     (dump_func)dump_queue_exception_event_request,
2114     (dump_func)dump_get_exception_status_request,
2115     (dump_func)dump_output_debug_string_request,
2116     (dump_func)dump_continue_debug_event_request,
2117     (dump_func)dump_debug_process_request,
2118     (dump_func)dump_read_process_memory_request,
2119     (dump_func)dump_write_process_memory_request,
2120     (dump_func)dump_create_key_request,
2121     (dump_func)dump_open_key_request,
2122     (dump_func)dump_delete_key_request,
2123     (dump_func)dump_enum_key_request,
2124     (dump_func)dump_set_key_value_request,
2125     (dump_func)dump_get_key_value_request,
2126     (dump_func)dump_enum_key_value_request,
2127     (dump_func)dump_delete_key_value_request,
2128     (dump_func)dump_load_registry_request,
2129     (dump_func)dump_save_registry_request,
2130     (dump_func)dump_save_registry_atexit_request,
2131     (dump_func)dump_set_registry_levels_request,
2132     (dump_func)dump_create_timer_request,
2133     (dump_func)dump_open_timer_request,
2134     (dump_func)dump_set_timer_request,
2135     (dump_func)dump_cancel_timer_request,
2136     (dump_func)dump_get_thread_context_request,
2137     (dump_func)dump_set_thread_context_request,
2138     (dump_func)dump_get_selector_entry_request,
2139     (dump_func)dump_add_atom_request,
2140     (dump_func)dump_delete_atom_request,
2141     (dump_func)dump_find_atom_request,
2142     (dump_func)dump_get_atom_name_request,
2143     (dump_func)dump_init_atom_table_request,
2144     (dump_func)dump_get_msg_queue_request,
2145     (dump_func)dump_set_queue_mask_request,
2146     (dump_func)dump_get_queue_status_request,
2147     (dump_func)dump_wait_input_idle_request,
2148     (dump_func)dump_send_message_request,
2149     (dump_func)dump_get_message_request,
2150     (dump_func)dump_reply_message_request,
2151     (dump_func)dump_get_message_reply_request,
2152     (dump_func)dump_set_win_timer_request,
2153     (dump_func)dump_kill_win_timer_request,
2154     (dump_func)dump_create_serial_request,
2155     (dump_func)dump_get_serial_info_request,
2156     (dump_func)dump_set_serial_info_request,
2157     (dump_func)dump_register_async_request,
2158     (dump_func)dump_create_named_pipe_request,
2159     (dump_func)dump_open_named_pipe_request,
2160     (dump_func)dump_connect_named_pipe_request,
2161     (dump_func)dump_wait_named_pipe_request,
2162     (dump_func)dump_disconnect_named_pipe_request,
2163     (dump_func)dump_get_named_pipe_info_request,
2164     (dump_func)dump_create_window_request,
2165     (dump_func)dump_link_window_request,
2166     (dump_func)dump_destroy_window_request,
2167     (dump_func)dump_set_window_owner_request,
2168     (dump_func)dump_get_window_info_request,
2169     (dump_func)dump_set_window_info_request,
2170     (dump_func)dump_get_window_parents_request,
2171     (dump_func)dump_get_window_children_request,
2172     (dump_func)dump_get_window_tree_request,
2173     (dump_func)dump_set_window_rectangles_request,
2174     (dump_func)dump_get_window_rectangles_request,
2175     (dump_func)dump_get_window_text_request,
2176     (dump_func)dump_set_window_text_request,
2177     (dump_func)dump_inc_window_paint_count_request,
2178     (dump_func)dump_get_windows_offset_request,
2179     (dump_func)dump_set_window_property_request,
2180     (dump_func)dump_remove_window_property_request,
2181     (dump_func)dump_get_window_property_request,
2182     (dump_func)dump_get_window_properties_request,
2183 };
2184
2185 static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
2186     (dump_func)dump_new_process_reply,
2187     (dump_func)dump_get_new_process_info_reply,
2188     (dump_func)dump_new_thread_reply,
2189     (dump_func)0,
2190     (dump_func)dump_init_process_reply,
2191     (dump_func)dump_init_process_done_reply,
2192     (dump_func)dump_init_thread_reply,
2193     (dump_func)dump_terminate_process_reply,
2194     (dump_func)dump_terminate_thread_reply,
2195     (dump_func)dump_get_process_info_reply,
2196     (dump_func)0,
2197     (dump_func)dump_get_thread_info_reply,
2198     (dump_func)0,
2199     (dump_func)dump_suspend_thread_reply,
2200     (dump_func)dump_resume_thread_reply,
2201     (dump_func)0,
2202     (dump_func)0,
2203     (dump_func)0,
2204     (dump_func)dump_get_apc_reply,
2205     (dump_func)dump_close_handle_reply,
2206     (dump_func)dump_set_handle_info_reply,
2207     (dump_func)dump_dup_handle_reply,
2208     (dump_func)dump_open_process_reply,
2209     (dump_func)0,
2210     (dump_func)dump_create_event_reply,
2211     (dump_func)0,
2212     (dump_func)dump_open_event_reply,
2213     (dump_func)dump_create_mutex_reply,
2214     (dump_func)0,
2215     (dump_func)dump_open_mutex_reply,
2216     (dump_func)dump_create_semaphore_reply,
2217     (dump_func)dump_release_semaphore_reply,
2218     (dump_func)dump_open_semaphore_reply,
2219     (dump_func)dump_create_file_reply,
2220     (dump_func)dump_alloc_file_handle_reply,
2221     (dump_func)dump_get_handle_fd_reply,
2222     (dump_func)dump_set_file_pointer_reply,
2223     (dump_func)0,
2224     (dump_func)0,
2225     (dump_func)0,
2226     (dump_func)dump_get_file_info_reply,
2227     (dump_func)0,
2228     (dump_func)0,
2229     (dump_func)dump_create_pipe_reply,
2230     (dump_func)dump_create_socket_reply,
2231     (dump_func)dump_accept_socket_reply,
2232     (dump_func)0,
2233     (dump_func)dump_get_socket_event_reply,
2234     (dump_func)0,
2235     (dump_func)dump_alloc_console_reply,
2236     (dump_func)0,
2237     (dump_func)dump_get_console_renderer_events_reply,
2238     (dump_func)dump_open_console_reply,
2239     (dump_func)dump_get_console_mode_reply,
2240     (dump_func)0,
2241     (dump_func)0,
2242     (dump_func)dump_get_console_input_info_reply,
2243     (dump_func)0,
2244     (dump_func)dump_get_console_input_history_reply,
2245     (dump_func)dump_create_console_output_reply,
2246     (dump_func)0,
2247     (dump_func)dump_get_console_output_info_reply,
2248     (dump_func)dump_write_console_input_reply,
2249     (dump_func)dump_read_console_input_reply,
2250     (dump_func)dump_write_console_output_reply,
2251     (dump_func)dump_fill_console_output_reply,
2252     (dump_func)dump_read_console_output_reply,
2253     (dump_func)0,
2254     (dump_func)dump_create_change_notification_reply,
2255     (dump_func)dump_create_mapping_reply,
2256     (dump_func)dump_open_mapping_reply,
2257     (dump_func)dump_get_mapping_info_reply,
2258     (dump_func)dump_create_device_reply,
2259     (dump_func)dump_create_snapshot_reply,
2260     (dump_func)dump_next_process_reply,
2261     (dump_func)dump_next_thread_reply,
2262     (dump_func)dump_next_module_reply,
2263     (dump_func)dump_wait_debug_event_reply,
2264     (dump_func)dump_queue_exception_event_reply,
2265     (dump_func)dump_get_exception_status_reply,
2266     (dump_func)0,
2267     (dump_func)0,
2268     (dump_func)0,
2269     (dump_func)dump_read_process_memory_reply,
2270     (dump_func)0,
2271     (dump_func)dump_create_key_reply,
2272     (dump_func)dump_open_key_reply,
2273     (dump_func)0,
2274     (dump_func)dump_enum_key_reply,
2275     (dump_func)0,
2276     (dump_func)dump_get_key_value_reply,
2277     (dump_func)dump_enum_key_value_reply,
2278     (dump_func)0,
2279     (dump_func)0,
2280     (dump_func)0,
2281     (dump_func)0,
2282     (dump_func)0,
2283     (dump_func)dump_create_timer_reply,
2284     (dump_func)dump_open_timer_reply,
2285     (dump_func)0,
2286     (dump_func)0,
2287     (dump_func)dump_get_thread_context_reply,
2288     (dump_func)0,
2289     (dump_func)dump_get_selector_entry_reply,
2290     (dump_func)dump_add_atom_reply,
2291     (dump_func)0,
2292     (dump_func)dump_find_atom_reply,
2293     (dump_func)dump_get_atom_name_reply,
2294     (dump_func)0,
2295     (dump_func)dump_get_msg_queue_reply,
2296     (dump_func)dump_set_queue_mask_reply,
2297     (dump_func)dump_get_queue_status_reply,
2298     (dump_func)dump_wait_input_idle_reply,
2299     (dump_func)0,
2300     (dump_func)dump_get_message_reply,
2301     (dump_func)0,
2302     (dump_func)dump_get_message_reply_reply,
2303     (dump_func)0,
2304     (dump_func)0,
2305     (dump_func)dump_create_serial_reply,
2306     (dump_func)dump_get_serial_info_reply,
2307     (dump_func)0,
2308     (dump_func)0,
2309     (dump_func)dump_create_named_pipe_reply,
2310     (dump_func)dump_open_named_pipe_reply,
2311     (dump_func)0,
2312     (dump_func)0,
2313     (dump_func)0,
2314     (dump_func)dump_get_named_pipe_info_reply,
2315     (dump_func)dump_create_window_reply,
2316     (dump_func)dump_link_window_reply,
2317     (dump_func)0,
2318     (dump_func)dump_set_window_owner_reply,
2319     (dump_func)dump_get_window_info_reply,
2320     (dump_func)dump_set_window_info_reply,
2321     (dump_func)dump_get_window_parents_reply,
2322     (dump_func)dump_get_window_children_reply,
2323     (dump_func)dump_get_window_tree_reply,
2324     (dump_func)0,
2325     (dump_func)dump_get_window_rectangles_reply,
2326     (dump_func)dump_get_window_text_reply,
2327     (dump_func)0,
2328     (dump_func)0,
2329     (dump_func)dump_get_windows_offset_reply,
2330     (dump_func)0,
2331     (dump_func)dump_remove_window_property_reply,
2332     (dump_func)dump_get_window_property_reply,
2333     (dump_func)dump_get_window_properties_reply,
2334 };
2335
2336 static const char * const req_names[REQ_NB_REQUESTS] = {
2337     "new_process",
2338     "get_new_process_info",
2339     "new_thread",
2340     "boot_done",
2341     "init_process",
2342     "init_process_done",
2343     "init_thread",
2344     "terminate_process",
2345     "terminate_thread",
2346     "get_process_info",
2347     "set_process_info",
2348     "get_thread_info",
2349     "set_thread_info",
2350     "suspend_thread",
2351     "resume_thread",
2352     "load_dll",
2353     "unload_dll",
2354     "queue_apc",
2355     "get_apc",
2356     "close_handle",
2357     "set_handle_info",
2358     "dup_handle",
2359     "open_process",
2360     "select",
2361     "create_event",
2362     "event_op",
2363     "open_event",
2364     "create_mutex",
2365     "release_mutex",
2366     "open_mutex",
2367     "create_semaphore",
2368     "release_semaphore",
2369     "open_semaphore",
2370     "create_file",
2371     "alloc_file_handle",
2372     "get_handle_fd",
2373     "set_file_pointer",
2374     "truncate_file",
2375     "set_file_time",
2376     "flush_file",
2377     "get_file_info",
2378     "lock_file",
2379     "unlock_file",
2380     "create_pipe",
2381     "create_socket",
2382     "accept_socket",
2383     "set_socket_event",
2384     "get_socket_event",
2385     "enable_socket_event",
2386     "alloc_console",
2387     "free_console",
2388     "get_console_renderer_events",
2389     "open_console",
2390     "get_console_mode",
2391     "set_console_mode",
2392     "set_console_input_info",
2393     "get_console_input_info",
2394     "append_console_input_history",
2395     "get_console_input_history",
2396     "create_console_output",
2397     "set_console_output_info",
2398     "get_console_output_info",
2399     "write_console_input",
2400     "read_console_input",
2401     "write_console_output",
2402     "fill_console_output",
2403     "read_console_output",
2404     "move_console_output",
2405     "create_change_notification",
2406     "create_mapping",
2407     "open_mapping",
2408     "get_mapping_info",
2409     "create_device",
2410     "create_snapshot",
2411     "next_process",
2412     "next_thread",
2413     "next_module",
2414     "wait_debug_event",
2415     "queue_exception_event",
2416     "get_exception_status",
2417     "output_debug_string",
2418     "continue_debug_event",
2419     "debug_process",
2420     "read_process_memory",
2421     "write_process_memory",
2422     "create_key",
2423     "open_key",
2424     "delete_key",
2425     "enum_key",
2426     "set_key_value",
2427     "get_key_value",
2428     "enum_key_value",
2429     "delete_key_value",
2430     "load_registry",
2431     "save_registry",
2432     "save_registry_atexit",
2433     "set_registry_levels",
2434     "create_timer",
2435     "open_timer",
2436     "set_timer",
2437     "cancel_timer",
2438     "get_thread_context",
2439     "set_thread_context",
2440     "get_selector_entry",
2441     "add_atom",
2442     "delete_atom",
2443     "find_atom",
2444     "get_atom_name",
2445     "init_atom_table",
2446     "get_msg_queue",
2447     "set_queue_mask",
2448     "get_queue_status",
2449     "wait_input_idle",
2450     "send_message",
2451     "get_message",
2452     "reply_message",
2453     "get_message_reply",
2454     "set_win_timer",
2455     "kill_win_timer",
2456     "create_serial",
2457     "get_serial_info",
2458     "set_serial_info",
2459     "register_async",
2460     "create_named_pipe",
2461     "open_named_pipe",
2462     "connect_named_pipe",
2463     "wait_named_pipe",
2464     "disconnect_named_pipe",
2465     "get_named_pipe_info",
2466     "create_window",
2467     "link_window",
2468     "destroy_window",
2469     "set_window_owner",
2470     "get_window_info",
2471     "set_window_info",
2472     "get_window_parents",
2473     "get_window_children",
2474     "get_window_tree",
2475     "set_window_rectangles",
2476     "get_window_rectangles",
2477     "get_window_text",
2478     "set_window_text",
2479     "inc_window_paint_count",
2480     "get_windows_offset",
2481     "set_window_property",
2482     "remove_window_property",
2483     "get_window_property",
2484     "get_window_properties",
2485 };
2486
2487 /* ### make_requests end ### */
2488 /* Everything above this line is generated automatically by tools/make_requests */
2489
2490 static const char *get_status_name( unsigned int status )
2491 {
2492 #define NAME(status)  { #status, STATUS_##status }
2493     static const struct
2494     {
2495         const char  *name;
2496         unsigned int value;
2497     } status_names[] =
2498     {
2499         NAME(ACCESS_DENIED),
2500         NAME(ACCESS_VIOLATION),
2501         NAME(BUFFER_OVERFLOW),
2502         NAME(CHILD_MUST_BE_VOLATILE),
2503         NAME(DIRECTORY_NOT_EMPTY),
2504         NAME(DISK_FULL),
2505         NAME(FILE_LOCK_CONFLICT),
2506         NAME(INVALID_FILE_FOR_SECTION),
2507         NAME(INVALID_HANDLE),
2508         NAME(INVALID_PARAMETER),
2509         NAME(KEY_DELETED),
2510         NAME(MEDIA_WRITE_PROTECTED),
2511         NAME(MUTANT_NOT_OWNED),
2512         NAME(NOT_REGISTRY_FILE),
2513         NAME(NO_MEMORY),
2514         NAME(NO_MORE_ENTRIES),
2515         NAME(NO_MORE_FILES),
2516         NAME(NO_SUCH_FILE),
2517         NAME(OBJECT_NAME_COLLISION),
2518         NAME(OBJECT_NAME_INVALID),
2519         NAME(OBJECT_NAME_NOT_FOUND),
2520         NAME(OBJECT_PATH_INVALID),
2521         NAME(OBJECT_TYPE_MISMATCH),
2522         NAME(PENDING),
2523         NAME(PIPE_BROKEN),
2524         NAME(SEMAPHORE_LIMIT_EXCEEDED),
2525         NAME(SHARING_VIOLATION),
2526         NAME(SUSPEND_COUNT_EXCEEDED),
2527         NAME(TIMEOUT),
2528         NAME(TOO_MANY_OPENED_FILES),
2529         NAME(UNSUCCESSFUL),
2530         NAME(USER_APC),
2531         { NULL, 0 }  /* terminator */
2532     };
2533 #undef NAME
2534
2535     int i;
2536     static char buffer[10];
2537
2538     if (status)
2539     {
2540         for (i = 0; status_names[i].name; i++)
2541             if (status_names[i].value == status) return status_names[i].name;
2542     }
2543     sprintf( buffer, "%x", status );
2544     return buffer;
2545 }
2546
2547 void trace_request(void)
2548 {
2549     enum request req = current->req.request_header.req;
2550     if (req < REQ_NB_REQUESTS)
2551     {
2552         fprintf( stderr, "%08x: %s(", (unsigned int)current, req_names[req] );
2553         if (req_dumpers[req])
2554         {
2555             cur_pos = 0;
2556             cur_data = get_req_data();
2557             cur_size = get_req_data_size();
2558             req_dumpers[req]( &current->req );
2559         }
2560         fprintf( stderr, " )\n" );
2561     }
2562     else fprintf( stderr, "%08x: %d(?)\n", (unsigned int)current, req );
2563 }
2564
2565 void trace_reply( enum request req, const union generic_reply *reply )
2566 {
2567     if (req < REQ_NB_REQUESTS)
2568     {
2569         fprintf( stderr, "%08x: %s() = %s",
2570                  (unsigned int)current, req_names[req], get_status_name(current->error) );
2571         if (reply_dumpers[req])
2572         {
2573             fprintf( stderr, " {" );
2574             cur_pos = 0;
2575             cur_data = current->reply_data;
2576             cur_size = reply->reply_header.reply_size;
2577             reply_dumpers[req]( reply );
2578             fprintf( stderr, " }" );
2579         }
2580         fputc( '\n', stderr );
2581     }
2582     else fprintf( stderr, "%08x: %d() = %s\n",
2583                   (unsigned int)current, req, get_status_name(current->error) );
2584 }