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