server/trace.c

   1 /*
   2  * Server request tracing
   3  *
   4  * Copyright (C) 1999 Alexandre Julliard
   5  */
   6
   7 #include <ctype.h>
   8 #include <stdio.h>
   9 #include <sys/types.h>
  10 #include <sys/uio.h>
  11 #include "winsock2.h"
  12 #include "winnt.h"
  13 #include "request.h"
  14 #include "unicode.h"
  15
  16
  17 /* utility functions */
  18
  19 static void dump_ints( const int *ptr, int len )
  20 {
  21     fputc( '{', stderr );
  22     while (len)
  23     {
  24         fprintf( stderr, "%d", *ptr++ );
  25         if (--len) fputc( ',', stderr );
  26     }
  27     fputc( '}', stderr );
  28 }
  29
  30 static void dump_uints( const int *ptr, int len )
  31 {
  32     fputc( '{', stderr );
  33     while (len)
  34     {
  35         fprintf( stderr, "%08x", *ptr++ );
  36         if (--len) fputc( ',', stderr );
  37     }
  38     fputc( '}', stderr );
  39 }
  40
  41 static void dump_bytes( const unsigned char *ptr, int len )
  42 {
  43     fputc( '{', stderr );
  44     while (len)
  45     {
  46         fprintf( stderr, "%02x", *ptr++ );
  47         if (--len) fputc( ',', stderr );
  48     }
  49     fputc( '}', stderr );
  50 }
  51
  52 static void dump_unicode_string( const WCHAR *str )
  53 {
  54     fprintf( stderr, "L\"" );
  55     dump_strW( str, strlenW(str), stderr, "\"\"" );
  56     fputc( '\"', stderr );
  57 }
  58
  59 static void dump_path_t( const path_t *path )
  60 {
  61     dump_unicode_string( *path );
  62 }
  63
  64 static void dump_context( const CONTEXT *context )
  65 {
  66 #ifdef __i386__
  67     fprintf( stderr, "{flags=%08lx,eax=%08lx,ebx=%08lx,ecx=%08lx,edx=%08lx,esi=%08lx,edi=%08lx,"
  68              "ebp=%08lx,eip=%08lx,esp=%08lx,eflags=%08lx,cs=%04lx,ds=%04lx,es=%04lx,"
  69              "fs=%04lx,gs=%04lx,dr0=%08lx,dr1=%08lx,dr2=%08lx,dr3=%08lx,dr6=%08lx,dr7=%08lx,",
  70              context->ContextFlags, context->Eax, context->Ebx, context->Ecx, context->Edx,
  71              context->Esi, context->Edi, context->Ebp, context->Eip, context->Esp, context->EFlags,
  72              context->SegCs, context->SegDs, context->SegEs, context->SegFs, context->SegGs,
  73              context->Dr0, context->Dr1, context->Dr2, context->Dr3, context->Dr6, context->Dr7 );
  74     fprintf( stderr, "float=" );
  75     dump_uints( (int *)&context->FloatSave, sizeof(context->FloatSave) / sizeof(int) );
  76     fprintf( stderr, "}" );
  77 #else
  78     dump_uints( (int *)context, sizeof(*context) / sizeof(int) );
  79 #endif
  80 }
  81
  82 static void dump_debug_event_t( const debug_event_t *event )
  83 {
  84     int i;
  85     switch(event->code)
  86     {
  87     case EXCEPTION_DEBUG_EVENT:
  88         fprintf( stderr, "{exception,code=%x,flags=%x,rec=%p,addr=%p,params={",
  89                  event->info.exception.code, event->info.exception.flags,
  90                  event->info.exception.record, event->info.exception.addr );
  91         for (i = 0; i < event->info.exception.nb_params; i++)
  92         {
  93             if (i) fputc( ',', stderr );
  94             fprintf( stderr, "%x", event->info.exception.params[i] );
  95         }
  96         fprintf( stderr, "},first_chance=%d,context=", event->info.exception.first_chance );
  97         dump_context( &event->info.exception.context );
  98         fputc( '}', stderr );
  99         break;
 100     case CREATE_THREAD_DEBUG_EVENT:
 101         fprintf( stderr, "{create_thread,thread=%d,teb=%p,start=%p}",
 102                  event->info.create_thread.handle, event->info.create_thread.teb,
 103                  event->info.create_thread.start );
 104         break;
 105     case CREATE_PROCESS_DEBUG_EVENT:
 106         fprintf( stderr, "{create_process,file=%d,process=%d,thread=%d,base=%p,offset=%d,"
 107                          "size=%d,teb=%p,start=%p,name=%p,unicode=%d}",
 108                  event->info.create_process.file, event->info.create_process.process,
 109                  event->info.create_process.thread, event->info.create_process.base,
 110                  event->info.create_process.dbg_offset, event->info.create_process.dbg_size,
 111                  event->info.create_process.teb, event->info.create_process.start,
 112                  event->info.create_process.name, event->info.create_process.unicode );
 113         break;
 114     case EXIT_THREAD_DEBUG_EVENT:
 115         fprintf( stderr, "{exit_thread,code=%d}", event->info.exit.exit_code );
 116         break;
 117     case EXIT_PROCESS_DEBUG_EVENT:
 118         fprintf( stderr, "{exit_process,code=%d}", event->info.exit.exit_code );
 119         break;
 120     case LOAD_DLL_DEBUG_EVENT:
 121         fprintf( stderr, "{load_dll,file=%d,base=%p,offset=%d,size=%d,name=%p,unicode=%d}",
 122                  event->info.load_dll.handle, event->info.load_dll.base,
 123                  event->info.load_dll.dbg_offset, event->info.load_dll.dbg_size,
 124                  event->info.load_dll.name, event->info.load_dll.unicode );
 125         break;
 126     case UNLOAD_DLL_DEBUG_EVENT:
 127         fprintf( stderr, "{unload_dll,base=%p}", event->info.unload_dll.base );
 128         break;
 129     case OUTPUT_DEBUG_STRING_EVENT:
 130         fprintf( stderr, "{output_string,data=%p,unicode=%d,len=%d}",
 131                  event->info.output_string.string, event->info.output_string.unicode,
 132                  event->info.output_string.length );
 133         break;
 134     case RIP_EVENT:
 135         fprintf( stderr, "{rip,err=%d,type=%d}",
 136                  event->info.rip_info.error, event->info.rip_info.type );
 137         break;
 138     case 0:  /* zero is the code returned on timeouts */
 139         fprintf( stderr, "{}" );
 140         break;
 141     default:
 142         fprintf( stderr, "{code=??? (%d)}", event->code );
 143         break;
 144     }
 145 }
 146
 147
 148 /* dumping for functions for requests that have a variable part */
 149
 150 static void dump_varargs_select_request( const struct select_request *req )
 151 {
 152     dump_ints( req->handles, req->count );
 153 }
 154
 155 static void dump_varargs_get_apcs_reply( const struct get_apcs_request *req )
 156 {
 157     int i;
 158     for (i = 0; i < 2 * req->count; i++)
 159         fprintf( stderr, "%c%p", i ? ',' : '{', req->apcs[i] );
 160     fprintf( stderr, "}" );
 161 }
 162
 163 static void dump_varargs_get_socket_event_reply( const struct get_socket_event_request *req )
 164 {
 165     dump_ints( req->errors, FD_MAX_EVENTS );
 166 }
 167
 168 static void dump_varargs_read_process_memory_reply( const struct read_process_memory_request *req )
 169 {
 170     int count = MIN( req->len, get_req_size( req->data, sizeof(int) ) );
 171     dump_bytes( (unsigned char *)req->data, count * sizeof(int) );
 172 }
 173
 174 static void dump_varargs_write_process_memory_request( const struct write_process_memory_request *req )
 175 {
 176     int count = MIN( req->len, get_req_size( req->data, sizeof(int) ) );
 177     dump_bytes( (unsigned char *)req->data, count * sizeof(int) );
 178 }
 179
 180 static void dump_varargs_set_key_value_request( const struct set_key_value_request *req )
 181 {
 182     dump_bytes( req->data, req->len );
 183 }
 184
 185 static void dump_varargs_get_key_value_reply( const struct get_key_value_request *req )
 186 {
 187     dump_bytes( req->data, req->len );
 188 }
 189
 190 static void dump_varargs_enum_key_value_reply( const struct enum_key_value_request *req )
 191 {
 192     dump_bytes( req->data, req->len );
 193 }
 194
 195 typedef void (*dump_func)( const void *req );
 196
 197 /* Everything below this line is generated automatically by tools/make_requests */
 198 /* ### make_requests begin ### */
 199
 200 static void dump_new_process_request( const struct new_process_request *req )
 201 {
 202     fprintf( stderr, " inherit=%d,", req->inherit );
 203     fprintf( stderr, " inherit_all=%d,", req->inherit_all );
 204     fprintf( stderr, " create_flags=%d,", req->create_flags );
 205     fprintf( stderr, " start_flags=%d,", req->start_flags );
 206     fprintf( stderr, " hstdin=%d,", req->hstdin );
 207     fprintf( stderr, " hstdout=%d,", req->hstdout );
 208     fprintf( stderr, " hstderr=%d,", req->hstderr );
 209     fprintf( stderr, " event=%d,", req->event );
 210     fprintf( stderr, " cmd_show=%d,", req->cmd_show );
 211     fprintf( stderr, " env_ptr=%p,", req->env_ptr );
 212     fprintf( stderr, " cmdline=\"%s\"", req->cmdline );
 213 }
 214
 215 static void dump_new_process_reply( const struct new_process_request *req )
 216 {
 217     fprintf( stderr, " pid=%p,", req->pid );
 218     fprintf( stderr, " handle=%d", req->handle );
 219 }
 220
 221 static void dump_new_thread_request( const struct new_thread_request *req )
 222 {
 223     fprintf( stderr, " pid=%p,", req->pid );
 224     fprintf( stderr, " suspend=%d,", req->suspend );
 225     fprintf( stderr, " inherit=%d", req->inherit );
 226 }
 227
 228 static void dump_new_thread_reply( const struct new_thread_request *req )
 229 {
 230     fprintf( stderr, " tid=%p,", req->tid );
 231     fprintf( stderr, " handle=%d", req->handle );
 232 }
 233
 234 static void dump_set_debug_request( const struct set_debug_request *req )
 235 {
 236     fprintf( stderr, " level=%d", req->level );
 237 }
 238
 239 static void dump_init_process_request( const struct init_process_request *req )
 240 {
 241 }
 242
 243 static void dump_init_process_reply( const struct init_process_request *req )
 244 {
 245     fprintf( stderr, " start_flags=%d,", req->start_flags );
 246     fprintf( stderr, " hstdin=%d,", req->hstdin );
 247     fprintf( stderr, " hstdout=%d,", req->hstdout );
 248     fprintf( stderr, " hstderr=%d,", req->hstderr );
 249     fprintf( stderr, " cmd_show=%d,", req->cmd_show );
 250     fprintf( stderr, " env_ptr=%p,", req->env_ptr );
 251     fprintf( stderr, " cmdline=\"%s\"", req->cmdline );
 252 }
 253
 254 static void dump_init_process_done_request( const struct init_process_done_request *req )
 255 {
 256     fprintf( stderr, " dummy=%d", req->dummy );
 257 }
 258
 259 static void dump_init_thread_request( const struct init_thread_request *req )
 260 {
 261     fprintf( stderr, " unix_pid=%d,", req->unix_pid );
 262     fprintf( stderr, " teb=%p", req->teb );
 263 }
 264
 265 static void dump_init_thread_reply( const struct init_thread_request *req )
 266 {
 267     fprintf( stderr, " pid=%p,", req->pid );
 268     fprintf( stderr, " tid=%p", req->tid );
 269 }
 270
 271 static void dump_get_thread_buffer_request( const struct get_thread_buffer_request *req )
 272 {
 273     fprintf( stderr, " dummy=%d", req->dummy );
 274 }
 275
 276 static void dump_terminate_process_request( const struct terminate_process_request *req )
 277 {
 278     fprintf( stderr, " handle=%d,", req->handle );
 279     fprintf( stderr, " exit_code=%d", req->exit_code );
 280 }
 281
 282 static void dump_terminate_thread_request( const struct terminate_thread_request *req )
 283 {
 284     fprintf( stderr, " handle=%d,", req->handle );
 285     fprintf( stderr, " exit_code=%d", req->exit_code );
 286 }
 287
 288 static void dump_get_process_info_request( const struct get_process_info_request *req )
 289 {
 290     fprintf( stderr, " handle=%d", req->handle );
 291 }
 292
 293 static void dump_get_process_info_reply( const struct get_process_info_request *req )
 294 {
 295     fprintf( stderr, " pid=%p,", req->pid );
 296     fprintf( stderr, " exit_code=%d,", req->exit_code );
 297     fprintf( stderr, " priority=%d,", req->priority );
 298     fprintf( stderr, " process_affinity=%d,", req->process_affinity );
 299     fprintf( stderr, " system_affinity=%d", req->system_affinity );
 300 }
 301
 302 static void dump_set_process_info_request( const struct set_process_info_request *req )
 303 {
 304     fprintf( stderr, " handle=%d,", req->handle );
 305     fprintf( stderr, " mask=%d,", req->mask );
 306     fprintf( stderr, " priority=%d,", req->priority );
 307     fprintf( stderr, " affinity=%d", req->affinity );
 308 }
 309
 310 static void dump_get_thread_info_request( const struct get_thread_info_request *req )
 311 {
 312     fprintf( stderr, " handle=%d", req->handle );
 313 }
 314
 315 static void dump_get_thread_info_reply( const struct get_thread_info_request *req )
 316 {
 317     fprintf( stderr, " tid=%p,", req->tid );
 318     fprintf( stderr, " exit_code=%d,", req->exit_code );
 319     fprintf( stderr, " priority=%d", req->priority );
 320 }
 321
 322 static void dump_set_thread_info_request( const struct set_thread_info_request *req )
 323 {
 324     fprintf( stderr, " handle=%d,", req->handle );
 325     fprintf( stderr, " mask=%d,", req->mask );
 326     fprintf( stderr, " priority=%d,", req->priority );
 327     fprintf( stderr, " affinity=%d", req->affinity );
 328 }
 329
 330 static void dump_suspend_thread_request( const struct suspend_thread_request *req )
 331 {
 332     fprintf( stderr, " handle=%d", req->handle );
 333 }
 334
 335 static void dump_suspend_thread_reply( const struct suspend_thread_request *req )
 336 {
 337     fprintf( stderr, " count=%d", req->count );
 338 }
 339
 340 static void dump_resume_thread_request( const struct resume_thread_request *req )
 341 {
 342     fprintf( stderr, " handle=%d", req->handle );
 343 }
 344
 345 static void dump_resume_thread_reply( const struct resume_thread_request *req )
 346 {
 347     fprintf( stderr, " count=%d", req->count );
 348 }
 349
 350 static void dump_debugger_request( const struct debugger_request *req )
 351 {
 352     fprintf( stderr, " op=%d", req->op );
 353 }
 354
 355 static void dump_queue_apc_request( const struct queue_apc_request *req )
 356 {
 357     fprintf( stderr, " handle=%d,", req->handle );
 358     fprintf( stderr, " func=%p,", req->func );
 359     fprintf( stderr, " param=%p", req->param );
 360 }
 361
 362 static void dump_get_apcs_request( const struct get_apcs_request *req )
 363 {
 364 }
 365
 366 static void dump_get_apcs_reply( const struct get_apcs_request *req )
 367 {
 368     fprintf( stderr, " count=%d,", req->count );
 369     fprintf( stderr, " apcs=" );
 370     dump_varargs_get_apcs_reply( req );
 371 }
 372
 373 static void dump_close_handle_request( const struct close_handle_request *req )
 374 {
 375     fprintf( stderr, " handle=%d", req->handle );
 376 }
 377
 378 static void dump_get_handle_info_request( const struct get_handle_info_request *req )
 379 {
 380     fprintf( stderr, " handle=%d", req->handle );
 381 }
 382
 383 static void dump_get_handle_info_reply( const struct get_handle_info_request *req )
 384 {
 385     fprintf( stderr, " flags=%d", req->flags );
 386 }
 387
 388 static void dump_set_handle_info_request( const struct set_handle_info_request *req )
 389 {
 390     fprintf( stderr, " handle=%d,", req->handle );
 391     fprintf( stderr, " flags=%d,", req->flags );
 392     fprintf( stderr, " mask=%d", req->mask );
 393 }
 394
 395 static void dump_dup_handle_request( const struct dup_handle_request *req )
 396 {
 397     fprintf( stderr, " src_process=%d,", req->src_process );
 398     fprintf( stderr, " src_handle=%d,", req->src_handle );
 399     fprintf( stderr, " dst_process=%d,", req->dst_process );
 400     fprintf( stderr, " access=%08x,", req->access );
 401     fprintf( stderr, " inherit=%d,", req->inherit );
 402     fprintf( stderr, " options=%d", req->options );
 403 }
 404
 405 static void dump_dup_handle_reply( const struct dup_handle_request *req )
 406 {
 407     fprintf( stderr, " handle=%d", req->handle );
 408 }
 409
 410 static void dump_open_process_request( const struct open_process_request *req )
 411 {
 412     fprintf( stderr, " pid=%p,", req->pid );
 413     fprintf( stderr, " access=%08x,", req->access );
 414     fprintf( stderr, " inherit=%d", req->inherit );
 415 }
 416
 417 static void dump_open_process_reply( const struct open_process_request *req )
 418 {
 419     fprintf( stderr, " handle=%d", req->handle );
 420 }
 421
 422 static void dump_select_request( const struct select_request *req )
 423 {
 424     fprintf( stderr, " count=%d,", req->count );
 425     fprintf( stderr, " flags=%d,", req->flags );
 426     fprintf( stderr, " timeout=%d,", req->timeout );
 427     fprintf( stderr, " handles=" );
 428     dump_varargs_select_request( req );
 429 }
 430
 431 static void dump_select_reply( const struct select_request *req )
 432 {
 433     fprintf( stderr, " signaled=%d", req->signaled );
 434 }
 435
 436 static void dump_create_event_request( const struct create_event_request *req )
 437 {
 438     fprintf( stderr, " manual_reset=%d,", req->manual_reset );
 439     fprintf( stderr, " initial_state=%d,", req->initial_state );
 440     fprintf( stderr, " inherit=%d,", req->inherit );
 441     fprintf( stderr, " name=" );
 442     dump_unicode_string( req->name );
 443 }
 444
 445 static void dump_create_event_reply( const struct create_event_request *req )
 446 {
 447     fprintf( stderr, " handle=%d", req->handle );
 448 }
 449
 450 static void dump_event_op_request( const struct event_op_request *req )
 451 {
 452     fprintf( stderr, " handle=%d,", req->handle );
 453     fprintf( stderr, " op=%d", req->op );
 454 }
 455
 456 static void dump_open_event_request( const struct open_event_request *req )
 457 {
 458     fprintf( stderr, " access=%08x,", req->access );
 459     fprintf( stderr, " inherit=%d,", req->inherit );
 460     fprintf( stderr, " name=" );
 461     dump_unicode_string( req->name );
 462 }
 463
 464 static void dump_open_event_reply( const struct open_event_request *req )
 465 {
 466     fprintf( stderr, " handle=%d", req->handle );
 467 }
 468
 469 static void dump_create_mutex_request( const struct create_mutex_request *req )
 470 {
 471     fprintf( stderr, " owned=%d,", req->owned );
 472     fprintf( stderr, " inherit=%d,", req->inherit );
 473     fprintf( stderr, " name=" );
 474     dump_unicode_string( req->name );
 475 }
 476
 477 static void dump_create_mutex_reply( const struct create_mutex_request *req )
 478 {
 479     fprintf( stderr, " handle=%d", req->handle );
 480 }
 481
 482 static void dump_release_mutex_request( const struct release_mutex_request *req )
 483 {
 484     fprintf( stderr, " handle=%d", req->handle );
 485 }
 486
 487 static void dump_open_mutex_request( const struct open_mutex_request *req )
 488 {
 489     fprintf( stderr, " access=%08x,", req->access );
 490     fprintf( stderr, " inherit=%d,", req->inherit );
 491     fprintf( stderr, " name=" );
 492     dump_unicode_string( req->name );
 493 }
 494
 495 static void dump_open_mutex_reply( const struct open_mutex_request *req )
 496 {
 497     fprintf( stderr, " handle=%d", req->handle );
 498 }
 499
 500 static void dump_create_semaphore_request( const struct create_semaphore_request *req )
 501 {
 502     fprintf( stderr, " initial=%08x,", req->initial );
 503     fprintf( stderr, " max=%08x,", req->max );
 504     fprintf( stderr, " inherit=%d,", req->inherit );
 505     fprintf( stderr, " name=" );
 506     dump_unicode_string( req->name );
 507 }
 508
 509 static void dump_create_semaphore_reply( const struct create_semaphore_request *req )
 510 {
 511     fprintf( stderr, " handle=%d", req->handle );
 512 }
 513
 514 static void dump_release_semaphore_request( const struct release_semaphore_request *req )
 515 {
 516     fprintf( stderr, " handle=%d,", req->handle );
 517     fprintf( stderr, " count=%08x", req->count );
 518 }
 519
 520 static void dump_release_semaphore_reply( const struct release_semaphore_request *req )
 521 {
 522     fprintf( stderr, " prev_count=%08x", req->prev_count );
 523 }
 524
 525 static void dump_open_semaphore_request( const struct open_semaphore_request *req )
 526 {
 527     fprintf( stderr, " access=%08x,", req->access );
 528     fprintf( stderr, " inherit=%d,", req->inherit );
 529     fprintf( stderr, " name=" );
 530     dump_unicode_string( req->name );
 531 }
 532
 533 static void dump_open_semaphore_reply( const struct open_semaphore_request *req )
 534 {
 535     fprintf( stderr, " handle=%d", req->handle );
 536 }
 537
 538 static void dump_create_file_request( const struct create_file_request *req )
 539 {
 540     fprintf( stderr, " access=%08x,", req->access );
 541     fprintf( stderr, " inherit=%d,", req->inherit );
 542     fprintf( stderr, " sharing=%08x,", req->sharing );
 543     fprintf( stderr, " create=%d,", req->create );
 544     fprintf( stderr, " attrs=%08x,", req->attrs );
 545     fprintf( stderr, " name=\"%s\"", req->name );
 546 }
 547
 548 static void dump_create_file_reply( const struct create_file_request *req )
 549 {
 550     fprintf( stderr, " handle=%d", req->handle );
 551 }
 552
 553 static void dump_alloc_file_handle_request( const struct alloc_file_handle_request *req )
 554 {
 555     fprintf( stderr, " access=%08x", req->access );
 556 }
 557
 558 static void dump_alloc_file_handle_reply( const struct alloc_file_handle_request *req )
 559 {
 560     fprintf( stderr, " handle=%d", req->handle );
 561 }
 562
 563 static void dump_get_read_fd_request( const struct get_read_fd_request *req )
 564 {
 565     fprintf( stderr, " handle=%d", req->handle );
 566 }
 567
 568 static void dump_get_write_fd_request( const struct get_write_fd_request *req )
 569 {
 570     fprintf( stderr, " handle=%d", req->handle );
 571 }
 572
 573 static void dump_set_file_pointer_request( const struct set_file_pointer_request *req )
 574 {
 575     fprintf( stderr, " handle=%d,", req->handle );
 576     fprintf( stderr, " low=%d,", req->low );
 577     fprintf( stderr, " high=%d,", req->high );
 578     fprintf( stderr, " whence=%d", req->whence );
 579 }
 580
 581 static void dump_set_file_pointer_reply( const struct set_file_pointer_request *req )
 582 {
 583     fprintf( stderr, " new_low=%d,", req->new_low );
 584     fprintf( stderr, " new_high=%d", req->new_high );
 585 }
 586
 587 static void dump_truncate_file_request( const struct truncate_file_request *req )
 588 {
 589     fprintf( stderr, " handle=%d", req->handle );
 590 }
 591
 592 static void dump_set_file_time_request( const struct set_file_time_request *req )
 593 {
 594     fprintf( stderr, " handle=%d,", req->handle );
 595     fprintf( stderr, " access_time=%ld,", req->access_time );
 596     fprintf( stderr, " write_time=%ld", req->write_time );
 597 }
 598
 599 static void dump_flush_file_request( const struct flush_file_request *req )
 600 {
 601     fprintf( stderr, " handle=%d", req->handle );
 602 }
 603
 604 static void dump_get_file_info_request( const struct get_file_info_request *req )
 605 {
 606     fprintf( stderr, " handle=%d", req->handle );
 607 }
 608
 609 static void dump_get_file_info_reply( const struct get_file_info_request *req )
 610 {
 611     fprintf( stderr, " type=%d,", req->type );
 612     fprintf( stderr, " attr=%d,", req->attr );
 613     fprintf( stderr, " access_time=%ld,", req->access_time );
 614     fprintf( stderr, " write_time=%ld,", req->write_time );
 615     fprintf( stderr, " size_high=%d,", req->size_high );
 616     fprintf( stderr, " size_low=%d,", req->size_low );
 617     fprintf( stderr, " links=%d,", req->links );
 618     fprintf( stderr, " index_high=%d,", req->index_high );
 619     fprintf( stderr, " index_low=%d,", req->index_low );
 620     fprintf( stderr, " serial=%08x", req->serial );
 621 }
 622
 623 static void dump_lock_file_request( const struct lock_file_request *req )
 624 {
 625     fprintf( stderr, " handle=%d,", req->handle );
 626     fprintf( stderr, " offset_low=%08x,", req->offset_low );
 627     fprintf( stderr, " offset_high=%08x,", req->offset_high );
 628     fprintf( stderr, " count_low=%08x,", req->count_low );
 629     fprintf( stderr, " count_high=%08x", req->count_high );
 630 }
 631
 632 static void dump_unlock_file_request( const struct unlock_file_request *req )
 633 {
 634     fprintf( stderr, " handle=%d,", req->handle );
 635     fprintf( stderr, " offset_low=%08x,", req->offset_low );
 636     fprintf( stderr, " offset_high=%08x,", req->offset_high );
 637     fprintf( stderr, " count_low=%08x,", req->count_low );
 638     fprintf( stderr, " count_high=%08x", req->count_high );
 639 }
 640
 641 static void dump_create_pipe_request( const struct create_pipe_request *req )
 642 {
 643     fprintf( stderr, " inherit=%d", req->inherit );
 644 }
 645
 646 static void dump_create_pipe_reply( const struct create_pipe_request *req )
 647 {
 648     fprintf( stderr, " handle_read=%d,", req->handle_read );
 649     fprintf( stderr, " handle_write=%d", req->handle_write );
 650 }
 651
 652 static void dump_create_socket_request( const struct create_socket_request *req )
 653 {
 654     fprintf( stderr, " access=%08x,", req->access );
 655     fprintf( stderr, " inherit=%d,", req->inherit );
 656     fprintf( stderr, " family=%d,", req->family );
 657     fprintf( stderr, " type=%d,", req->type );
 658     fprintf( stderr, " protocol=%d", req->protocol );
 659 }
 660
 661 static void dump_create_socket_reply( const struct create_socket_request *req )
 662 {
 663     fprintf( stderr, " handle=%d", req->handle );
 664 }
 665
 666 static void dump_accept_socket_request( const struct accept_socket_request *req )
 667 {
 668     fprintf( stderr, " lhandle=%d,", req->lhandle );
 669     fprintf( stderr, " access=%08x,", req->access );
 670     fprintf( stderr, " inherit=%d", req->inherit );
 671 }
 672
 673 static void dump_accept_socket_reply( const struct accept_socket_request *req )
 674 {
 675     fprintf( stderr, " handle=%d", req->handle );
 676 }
 677
 678 static void dump_set_socket_event_request( const struct set_socket_event_request *req )
 679 {
 680     fprintf( stderr, " handle=%d,", req->handle );
 681     fprintf( stderr, " mask=%08x,", req->mask );
 682     fprintf( stderr, " event=%d", req->event );
 683 }
 684
 685 static void dump_get_socket_event_request( const struct get_socket_event_request *req )
 686 {
 687     fprintf( stderr, " handle=%d,", req->handle );
 688     fprintf( stderr, " service=%d,", req->service );
 689     fprintf( stderr, " s_event=%d", req->s_event );
 690 }
 691
 692 static void dump_get_socket_event_reply( const struct get_socket_event_request *req )
 693 {
 694     fprintf( stderr, " mask=%08x,", req->mask );
 695     fprintf( stderr, " pmask=%08x,", req->pmask );
 696     fprintf( stderr, " state=%08x,", req->state );
 697     fprintf( stderr, " errors=" );
 698     dump_varargs_get_socket_event_reply( req );
 699 }
 700
 701 static void dump_enable_socket_event_request( const struct enable_socket_event_request *req )
 702 {
 703     fprintf( stderr, " handle=%d,", req->handle );
 704     fprintf( stderr, " mask=%08x,", req->mask );
 705     fprintf( stderr, " sstate=%08x,", req->sstate );
 706     fprintf( stderr, " cstate=%08x", req->cstate );
 707 }
 708
 709 static void dump_alloc_console_request( const struct alloc_console_request *req )
 710 {
 711     fprintf( stderr, " access=%08x,", req->access );
 712     fprintf( stderr, " inherit=%d", req->inherit );
 713 }
 714
 715 static void dump_alloc_console_reply( const struct alloc_console_request *req )
 716 {
 717     fprintf( stderr, " handle_in=%d,", req->handle_in );
 718     fprintf( stderr, " handle_out=%d", req->handle_out );
 719 }
 720
 721 static void dump_free_console_request( const struct free_console_request *req )
 722 {
 723     fprintf( stderr, " dummy=%d", req->dummy );
 724 }
 725
 726 static void dump_open_console_request( const struct open_console_request *req )
 727 {
 728     fprintf( stderr, " output=%d,", req->output );
 729     fprintf( stderr, " access=%08x,", req->access );
 730     fprintf( stderr, " inherit=%d", req->inherit );
 731 }
 732
 733 static void dump_open_console_reply( const struct open_console_request *req )
 734 {
 735     fprintf( stderr, " handle=%d", req->handle );
 736 }
 737
 738 static void dump_set_console_fd_request( const struct set_console_fd_request *req )
 739 {
 740     fprintf( stderr, " handle=%d,", req->handle );
 741     fprintf( stderr, " file_handle=%d,", req->file_handle );
 742     fprintf( stderr, " pid=%d", req->pid );
 743 }
 744
 745 static void dump_get_console_mode_request( const struct get_console_mode_request *req )
 746 {
 747     fprintf( stderr, " handle=%d", req->handle );
 748 }
 749
 750 static void dump_get_console_mode_reply( const struct get_console_mode_request *req )
 751 {
 752     fprintf( stderr, " mode=%d", req->mode );
 753 }
 754
 755 static void dump_set_console_mode_request( const struct set_console_mode_request *req )
 756 {
 757     fprintf( stderr, " handle=%d,", req->handle );
 758     fprintf( stderr, " mode=%d", req->mode );
 759 }
 760
 761 static void dump_set_console_info_request( const struct set_console_info_request *req )
 762 {
 763     fprintf( stderr, " handle=%d,", req->handle );
 764     fprintf( stderr, " mask=%d,", req->mask );
 765     fprintf( stderr, " cursor_size=%d,", req->cursor_size );
 766     fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
 767     fprintf( stderr, " title=\"%s\"", req->title );
 768 }
 769
 770 static void dump_get_console_info_request( const struct get_console_info_request *req )
 771 {
 772     fprintf( stderr, " handle=%d", req->handle );
 773 }
 774
 775 static void dump_get_console_info_reply( const struct get_console_info_request *req )
 776 {
 777     fprintf( stderr, " cursor_size=%d,", req->cursor_size );
 778     fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
 779     fprintf( stderr, " pid=%d,", req->pid );
 780     fprintf( stderr, " title=\"%s\"", req->title );
 781 }
 782
 783 static void dump_write_console_input_request( const struct write_console_input_request *req )
 784 {
 785     fprintf( stderr, " handle=%d,", req->handle );
 786     fprintf( stderr, " count=%d", req->count );
 787 }
 788
 789 static void dump_write_console_input_reply( const struct write_console_input_request *req )
 790 {
 791     fprintf( stderr, " written=%d", req->written );
 792 }
 793
 794 static void dump_read_console_input_request( const struct read_console_input_request *req )
 795 {
 796     fprintf( stderr, " handle=%d,", req->handle );
 797     fprintf( stderr, " count=%d,", req->count );
 798     fprintf( stderr, " flush=%d", req->flush );
 799 }
 800
 801 static void dump_read_console_input_reply( const struct read_console_input_request *req )
 802 {
 803     fprintf( stderr, " read=%d", req->read );
 804 }
 805
 806 static void dump_create_change_notification_request( const struct create_change_notification_request *req )
 807 {
 808     fprintf( stderr, " subtree=%d,", req->subtree );
 809     fprintf( stderr, " filter=%d", req->filter );
 810 }
 811
 812 static void dump_create_change_notification_reply( const struct create_change_notification_request *req )
 813 {
 814     fprintf( stderr, " handle=%d", req->handle );
 815 }
 816
 817 static void dump_create_mapping_request( const struct create_mapping_request *req )
 818 {
 819     fprintf( stderr, " size_high=%d,", req->size_high );
 820     fprintf( stderr, " size_low=%d,", req->size_low );
 821     fprintf( stderr, " protect=%d,", req->protect );
 822     fprintf( stderr, " inherit=%d,", req->inherit );
 823     fprintf( stderr, " file_handle=%d,", req->file_handle );
 824     fprintf( stderr, " name=" );
 825     dump_unicode_string( req->name );
 826 }
 827
 828 static void dump_create_mapping_reply( const struct create_mapping_request *req )
 829 {
 830     fprintf( stderr, " handle=%d", req->handle );
 831 }
 832
 833 static void dump_open_mapping_request( const struct open_mapping_request *req )
 834 {
 835     fprintf( stderr, " access=%08x,", req->access );
 836     fprintf( stderr, " inherit=%d,", req->inherit );
 837     fprintf( stderr, " name=" );
 838     dump_unicode_string( req->name );
 839 }
 840
 841 static void dump_open_mapping_reply( const struct open_mapping_request *req )
 842 {
 843     fprintf( stderr, " handle=%d", req->handle );
 844 }
 845
 846 static void dump_get_mapping_info_request( const struct get_mapping_info_request *req )
 847 {
 848     fprintf( stderr, " handle=%d", req->handle );
 849 }
 850
 851 static void dump_get_mapping_info_reply( const struct get_mapping_info_request *req )
 852 {
 853     fprintf( stderr, " size_high=%d,", req->size_high );
 854     fprintf( stderr, " size_low=%d,", req->size_low );
 855     fprintf( stderr, " protect=%d", req->protect );
 856 }
 857
 858 static void dump_create_device_request( const struct create_device_request *req )
 859 {
 860     fprintf( stderr, " access=%08x,", req->access );
 861     fprintf( stderr, " inherit=%d,", req->inherit );
 862     fprintf( stderr, " id=%d", req->id );
 863 }
 864
 865 static void dump_create_device_reply( const struct create_device_request *req )
 866 {
 867     fprintf( stderr, " handle=%d", req->handle );
 868 }
 869
 870 static void dump_create_snapshot_request( const struct create_snapshot_request *req )
 871 {
 872     fprintf( stderr, " inherit=%d,", req->inherit );
 873     fprintf( stderr, " flags=%d", req->flags );
 874 }
 875
 876 static void dump_create_snapshot_reply( const struct create_snapshot_request *req )
 877 {
 878     fprintf( stderr, " handle=%d", req->handle );
 879 }
 880
 881 static void dump_next_process_request( const struct next_process_request *req )
 882 {
 883     fprintf( stderr, " handle=%d,", req->handle );
 884     fprintf( stderr, " reset=%d", req->reset );
 885 }
 886
 887 static void dump_next_process_reply( const struct next_process_request *req )
 888 {
 889     fprintf( stderr, " pid=%p,", req->pid );
 890     fprintf( stderr, " threads=%d,", req->threads );
 891     fprintf( stderr, " priority=%d", req->priority );
 892 }
 893
 894 static void dump_wait_debug_event_request( const struct wait_debug_event_request *req )
 895 {
 896     fprintf( stderr, " timeout=%d", req->timeout );
 897 }
 898
 899 static void dump_wait_debug_event_reply( const struct wait_debug_event_request *req )
 900 {
 901     fprintf( stderr, " pid=%p,", req->pid );
 902     fprintf( stderr, " tid=%p,", req->tid );
 903     fprintf( stderr, " event=" );
 904     dump_debug_event_t( &req->event );
 905 }
 906
 907 static void dump_send_debug_event_request( const struct send_debug_event_request *req )
 908 {
 909     fprintf( stderr, " event=" );
 910     dump_debug_event_t( &req->event );
 911 }
 912
 913 static void dump_send_debug_event_reply( const struct send_debug_event_request *req )
 914 {
 915     fprintf( stderr, " status=%d", req->status );
 916 }
 917
 918 static void dump_continue_debug_event_request( const struct continue_debug_event_request *req )
 919 {
 920     fprintf( stderr, " pid=%p,", req->pid );
 921     fprintf( stderr, " tid=%p,", req->tid );
 922     fprintf( stderr, " status=%d", req->status );
 923 }
 924
 925 static void dump_debug_process_request( const struct debug_process_request *req )
 926 {
 927     fprintf( stderr, " pid=%p", req->pid );
 928 }
 929
 930 static void dump_read_process_memory_request( const struct read_process_memory_request *req )
 931 {
 932     fprintf( stderr, " handle=%d,", req->handle );
 933     fprintf( stderr, " addr=%p,", req->addr );
 934     fprintf( stderr, " len=%d", req->len );
 935 }
 936
 937 static void dump_read_process_memory_reply( const struct read_process_memory_request *req )
 938 {
 939     fprintf( stderr, " data=" );
 940     dump_varargs_read_process_memory_reply( req );
 941 }
 942
 943 static void dump_write_process_memory_request( const struct write_process_memory_request *req )
 944 {
 945     fprintf( stderr, " handle=%d,", req->handle );
 946     fprintf( stderr, " addr=%p,", req->addr );
 947     fprintf( stderr, " len=%d,", req->len );
 948     fprintf( stderr, " first_mask=%08x,", req->first_mask );
 949     fprintf( stderr, " last_mask=%08x,", req->last_mask );
 950     fprintf( stderr, " data=" );
 951     dump_varargs_write_process_memory_request( req );
 952 }
 953
 954 static void dump_create_key_request( const struct create_key_request *req )
 955 {
 956     fprintf( stderr, " parent=%d,", req->parent );
 957     fprintf( stderr, " access=%08x,", req->access );
 958     fprintf( stderr, " options=%08x,", req->options );
 959     fprintf( stderr, " modif=%ld,", req->modif );
 960     fprintf( stderr, " name=" );
 961     dump_path_t( &req->name );
 962     fprintf( stderr, "," );
 963     fprintf( stderr, " class=" );
 964     dump_unicode_string( req->class );
 965 }
 966
 967 static void dump_create_key_reply( const struct create_key_request *req )
 968 {
 969     fprintf( stderr, " hkey=%d,", req->hkey );
 970     fprintf( stderr, " created=%d", req->created );
 971 }
 972
 973 static void dump_open_key_request( const struct open_key_request *req )
 974 {
 975     fprintf( stderr, " parent=%d,", req->parent );
 976     fprintf( stderr, " access=%08x,", req->access );
 977     fprintf( stderr, " name=" );
 978     dump_path_t( &req->name );
 979 }
 980
 981 static void dump_open_key_reply( const struct open_key_request *req )
 982 {
 983     fprintf( stderr, " hkey=%d", req->hkey );
 984 }
 985
 986 static void dump_delete_key_request( const struct delete_key_request *req )
 987 {
 988     fprintf( stderr, " hkey=%d,", req->hkey );
 989     fprintf( stderr, " name=" );
 990     dump_path_t( &req->name );
 991 }
 992
 993 static void dump_close_key_request( const struct close_key_request *req )
 994 {
 995     fprintf( stderr, " hkey=%d", req->hkey );
 996 }
 997
 998 static void dump_enum_key_request( const struct enum_key_request *req )
 999 {
1000     fprintf( stderr, " hkey=%d,", req->hkey );
1001     fprintf( stderr, " index=%d", req->index );
1002 }
1003
1004 static void dump_enum_key_reply( const struct enum_key_request *req )
1005 {
1006     fprintf( stderr, " modif=%ld,", req->modif );
1007     fprintf( stderr, " name=" );
1008     dump_path_t( &req->name );
1009     fprintf( stderr, "," );
1010     fprintf( stderr, " class=" );
1011     dump_unicode_string( req->class );
1012 }
1013
1014 static void dump_query_key_info_request( const struct query_key_info_request *req )
1015 {
1016     fprintf( stderr, " hkey=%d", req->hkey );
1017 }
1018
1019 static void dump_query_key_info_reply( const struct query_key_info_request *req )
1020 {
1021     fprintf( stderr, " subkeys=%d,", req->subkeys );
1022     fprintf( stderr, " max_subkey=%d,", req->max_subkey );
1023     fprintf( stderr, " max_class=%d,", req->max_class );
1024     fprintf( stderr, " values=%d,", req->values );
1025     fprintf( stderr, " max_value=%d,", req->max_value );
1026     fprintf( stderr, " max_data=%d,", req->max_data );
1027     fprintf( stderr, " modif=%ld,", req->modif );
1028     fprintf( stderr, " name=" );
1029     dump_path_t( &req->name );
1030     fprintf( stderr, "," );
1031     fprintf( stderr, " class=" );
1032     dump_unicode_string( req->class );
1033 }
1034
1035 static void dump_set_key_value_request( const struct set_key_value_request *req )
1036 {
1037     fprintf( stderr, " hkey=%d,", req->hkey );
1038     fprintf( stderr, " type=%d,", req->type );
1039     fprintf( stderr, " len=%d,", req->len );
1040     fprintf( stderr, " name=" );
1041     dump_path_t( &req->name );
1042     fprintf( stderr, "," );
1043     fprintf( stderr, " data=" );
1044     dump_varargs_set_key_value_request( req );
1045 }
1046
1047 static void dump_get_key_value_request( const struct get_key_value_request *req )
1048 {
1049     fprintf( stderr, " hkey=%d,", req->hkey );
1050     fprintf( stderr, " name=" );
1051     dump_unicode_string( req->name );
1052 }
1053
1054 static void dump_get_key_value_reply( const struct get_key_value_request *req )
1055 {
1056     fprintf( stderr, " type=%d,", req->type );
1057     fprintf( stderr, " len=%d,", req->len );
1058     fprintf( stderr, " data=" );
1059     dump_varargs_get_key_value_reply( req );
1060 }
1061
1062 static void dump_enum_key_value_request( const struct enum_key_value_request *req )
1063 {
1064     fprintf( stderr, " hkey=%d,", req->hkey );
1065     fprintf( stderr, " index=%d", req->index );
1066 }
1067
1068 static void dump_enum_key_value_reply( const struct enum_key_value_request *req )
1069 {
1070     fprintf( stderr, " type=%d,", req->type );
1071     fprintf( stderr, " len=%d,", req->len );
1072     fprintf( stderr, " name=" );
1073     dump_path_t( &req->name );
1074     fprintf( stderr, "," );
1075     fprintf( stderr, " data=" );
1076     dump_varargs_enum_key_value_reply( req );
1077 }
1078
1079 static void dump_delete_key_value_request( const struct delete_key_value_request *req )
1080 {
1081     fprintf( stderr, " hkey=%d,", req->hkey );
1082     fprintf( stderr, " name=" );
1083     dump_path_t( &req->name );
1084 }
1085
1086 static void dump_load_registry_request( const struct load_registry_request *req )
1087 {
1088     fprintf( stderr, " hkey=%d,", req->hkey );
1089     fprintf( stderr, " file=%d,", req->file );
1090     fprintf( stderr, " name=" );
1091     dump_path_t( &req->name );
1092 }
1093
1094 static void dump_save_registry_request( const struct save_registry_request *req )
1095 {
1096     fprintf( stderr, " hkey=%d,", req->hkey );
1097     fprintf( stderr, " file=%d", req->file );
1098 }
1099
1100 static void dump_set_registry_levels_request( const struct set_registry_levels_request *req )
1101 {
1102     fprintf( stderr, " current=%d,", req->current );
1103     fprintf( stderr, " saving=%d,", req->saving );
1104     fprintf( stderr, " version=%d", req->version );
1105 }
1106
1107 static void dump_create_timer_request( const struct create_timer_request *req )
1108 {
1109     fprintf( stderr, " inherit=%d,", req->inherit );
1110     fprintf( stderr, " manual=%d,", req->manual );
1111     fprintf( stderr, " name=" );
1112     dump_unicode_string( req->name );
1113 }
1114
1115 static void dump_create_timer_reply( const struct create_timer_request *req )
1116 {
1117     fprintf( stderr, " handle=%d", req->handle );
1118 }
1119
1120 static void dump_open_timer_request( const struct open_timer_request *req )
1121 {
1122     fprintf( stderr, " access=%08x,", req->access );
1123     fprintf( stderr, " inherit=%d,", req->inherit );
1124     fprintf( stderr, " name=" );
1125     dump_unicode_string( req->name );
1126 }
1127
1128 static void dump_open_timer_reply( const struct open_timer_request *req )
1129 {
1130     fprintf( stderr, " handle=%d", req->handle );
1131 }
1132
1133 static void dump_set_timer_request( const struct set_timer_request *req )
1134 {
1135     fprintf( stderr, " handle=%d,", req->handle );
1136     fprintf( stderr, " sec=%d,", req->sec );
1137     fprintf( stderr, " usec=%d,", req->usec );
1138     fprintf( stderr, " period=%d,", req->period );
1139     fprintf( stderr, " callback=%p,", req->callback );
1140     fprintf( stderr, " arg=%p", req->arg );
1141 }
1142
1143 static void dump_cancel_timer_request( const struct cancel_timer_request *req )
1144 {
1145     fprintf( stderr, " handle=%d", req->handle );
1146 }
1147
1148 static void dump_get_thread_context_request( const struct get_thread_context_request *req )
1149 {
1150     fprintf( stderr, " handle=%d,", req->handle );
1151     fprintf( stderr, " flags=%08x", req->flags );
1152 }
1153
1154 static void dump_get_thread_context_reply( const struct get_thread_context_request *req )
1155 {
1156     fprintf( stderr, " context=" );
1157     dump_context( &req->context );
1158 }
1159
1160 static void dump_set_thread_context_request( const struct set_thread_context_request *req )
1161 {
1162     fprintf( stderr, " handle=%d,", req->handle );
1163     fprintf( stderr, " flags=%08x,", req->flags );
1164     fprintf( stderr, " context=" );
1165     dump_context( &req->context );
1166 }
1167
1168 static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
1169     (dump_func)dump_new_process_request,
1170     (dump_func)dump_new_thread_request,
1171     (dump_func)dump_set_debug_request,
1172     (dump_func)dump_init_process_request,
1173     (dump_func)dump_init_process_done_request,
1174     (dump_func)dump_init_thread_request,
1175     (dump_func)dump_get_thread_buffer_request,
1176     (dump_func)dump_terminate_process_request,
1177     (dump_func)dump_terminate_thread_request,
1178     (dump_func)dump_get_process_info_request,
1179     (dump_func)dump_set_process_info_request,
1180     (dump_func)dump_get_thread_info_request,
1181     (dump_func)dump_set_thread_info_request,
1182     (dump_func)dump_suspend_thread_request,
1183     (dump_func)dump_resume_thread_request,
1184     (dump_func)dump_debugger_request,
1185     (dump_func)dump_queue_apc_request,
1186     (dump_func)dump_get_apcs_request,
1187     (dump_func)dump_close_handle_request,
1188     (dump_func)dump_get_handle_info_request,
1189     (dump_func)dump_set_handle_info_request,
1190     (dump_func)dump_dup_handle_request,
1191     (dump_func)dump_open_process_request,
1192     (dump_func)dump_select_request,
1193     (dump_func)dump_create_event_request,
1194     (dump_func)dump_event_op_request,
1195     (dump_func)dump_open_event_request,
1196     (dump_func)dump_create_mutex_request,
1197     (dump_func)dump_release_mutex_request,
1198     (dump_func)dump_open_mutex_request,
1199     (dump_func)dump_create_semaphore_request,
1200     (dump_func)dump_release_semaphore_request,
1201     (dump_func)dump_open_semaphore_request,
1202     (dump_func)dump_create_file_request,
1203     (dump_func)dump_alloc_file_handle_request,
1204     (dump_func)dump_get_read_fd_request,
1205     (dump_func)dump_get_write_fd_request,
1206     (dump_func)dump_set_file_pointer_request,
1207     (dump_func)dump_truncate_file_request,
1208     (dump_func)dump_set_file_time_request,
1209     (dump_func)dump_flush_file_request,
1210     (dump_func)dump_get_file_info_request,
1211     (dump_func)dump_lock_file_request,
1212     (dump_func)dump_unlock_file_request,
1213     (dump_func)dump_create_pipe_request,
1214     (dump_func)dump_create_socket_request,
1215     (dump_func)dump_accept_socket_request,
1216     (dump_func)dump_set_socket_event_request,
1217     (dump_func)dump_get_socket_event_request,
1218     (dump_func)dump_enable_socket_event_request,
1219     (dump_func)dump_alloc_console_request,
1220     (dump_func)dump_free_console_request,
1221     (dump_func)dump_open_console_request,
1222     (dump_func)dump_set_console_fd_request,
1223     (dump_func)dump_get_console_mode_request,
1224     (dump_func)dump_set_console_mode_request,
1225     (dump_func)dump_set_console_info_request,
1226     (dump_func)dump_get_console_info_request,
1227     (dump_func)dump_write_console_input_request,
1228     (dump_func)dump_read_console_input_request,
1229     (dump_func)dump_create_change_notification_request,
1230     (dump_func)dump_create_mapping_request,
1231     (dump_func)dump_open_mapping_request,
1232     (dump_func)dump_get_mapping_info_request,
1233     (dump_func)dump_create_device_request,
1234     (dump_func)dump_create_snapshot_request,
1235     (dump_func)dump_next_process_request,
1236     (dump_func)dump_wait_debug_event_request,
1237     (dump_func)dump_send_debug_event_request,
1238     (dump_func)dump_continue_debug_event_request,
1239     (dump_func)dump_debug_process_request,
1240     (dump_func)dump_read_process_memory_request,
1241     (dump_func)dump_write_process_memory_request,
1242     (dump_func)dump_create_key_request,
1243     (dump_func)dump_open_key_request,
1244     (dump_func)dump_delete_key_request,
1245     (dump_func)dump_close_key_request,
1246     (dump_func)dump_enum_key_request,
1247     (dump_func)dump_query_key_info_request,
1248     (dump_func)dump_set_key_value_request,
1249     (dump_func)dump_get_key_value_request,
1250     (dump_func)dump_enum_key_value_request,
1251     (dump_func)dump_delete_key_value_request,
1252     (dump_func)dump_load_registry_request,
1253     (dump_func)dump_save_registry_request,
1254     (dump_func)dump_set_registry_levels_request,
1255     (dump_func)dump_create_timer_request,
1256     (dump_func)dump_open_timer_request,
1257     (dump_func)dump_set_timer_request,
1258     (dump_func)dump_cancel_timer_request,
1259     (dump_func)dump_get_thread_context_request,
1260     (dump_func)dump_set_thread_context_request,
1261 };
1262
1263 static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
1264     (dump_func)dump_new_process_reply,
1265     (dump_func)dump_new_thread_reply,
1266     (dump_func)0,
1267     (dump_func)dump_init_process_reply,
1268     (dump_func)0,
1269     (dump_func)dump_init_thread_reply,
1270     (dump_func)0,
1271     (dump_func)0,
1272     (dump_func)0,
1273     (dump_func)dump_get_process_info_reply,
1274     (dump_func)0,
1275     (dump_func)dump_get_thread_info_reply,
1276     (dump_func)0,
1277     (dump_func)dump_suspend_thread_reply,
1278     (dump_func)dump_resume_thread_reply,
1279     (dump_func)0,
1280     (dump_func)0,
1281     (dump_func)dump_get_apcs_reply,
1282     (dump_func)0,
1283     (dump_func)dump_get_handle_info_reply,
1284     (dump_func)0,
1285     (dump_func)dump_dup_handle_reply,
1286     (dump_func)dump_open_process_reply,
1287     (dump_func)dump_select_reply,
1288     (dump_func)dump_create_event_reply,
1289     (dump_func)0,
1290     (dump_func)dump_open_event_reply,
1291     (dump_func)dump_create_mutex_reply,
1292     (dump_func)0,
1293     (dump_func)dump_open_mutex_reply,
1294     (dump_func)dump_create_semaphore_reply,
1295     (dump_func)dump_release_semaphore_reply,
1296     (dump_func)dump_open_semaphore_reply,
1297     (dump_func)dump_create_file_reply,
1298     (dump_func)dump_alloc_file_handle_reply,
1299     (dump_func)0,
1300     (dump_func)0,
1301     (dump_func)dump_set_file_pointer_reply,
1302     (dump_func)0,
1303     (dump_func)0,
1304     (dump_func)0,
1305     (dump_func)dump_get_file_info_reply,
1306     (dump_func)0,
1307     (dump_func)0,
1308     (dump_func)dump_create_pipe_reply,
1309     (dump_func)dump_create_socket_reply,
1310     (dump_func)dump_accept_socket_reply,
1311     (dump_func)0,
1312     (dump_func)dump_get_socket_event_reply,
1313     (dump_func)0,
1314     (dump_func)dump_alloc_console_reply,
1315     (dump_func)0,
1316     (dump_func)dump_open_console_reply,
1317     (dump_func)0,
1318     (dump_func)dump_get_console_mode_reply,
1319     (dump_func)0,
1320     (dump_func)0,
1321     (dump_func)dump_get_console_info_reply,
1322     (dump_func)dump_write_console_input_reply,
1323     (dump_func)dump_read_console_input_reply,
1324     (dump_func)dump_create_change_notification_reply,
1325     (dump_func)dump_create_mapping_reply,
1326     (dump_func)dump_open_mapping_reply,
1327     (dump_func)dump_get_mapping_info_reply,
1328     (dump_func)dump_create_device_reply,
1329     (dump_func)dump_create_snapshot_reply,
1330     (dump_func)dump_next_process_reply,
1331     (dump_func)dump_wait_debug_event_reply,
1332     (dump_func)dump_send_debug_event_reply,
1333     (dump_func)0,
1334     (dump_func)0,
1335     (dump_func)dump_read_process_memory_reply,
1336     (dump_func)0,
1337     (dump_func)dump_create_key_reply,
1338     (dump_func)dump_open_key_reply,
1339     (dump_func)0,
1340     (dump_func)0,
1341     (dump_func)dump_enum_key_reply,
1342     (dump_func)dump_query_key_info_reply,
1343     (dump_func)0,
1344     (dump_func)dump_get_key_value_reply,
1345     (dump_func)dump_enum_key_value_reply,
1346     (dump_func)0,
1347     (dump_func)0,
1348     (dump_func)0,
1349     (dump_func)0,
1350     (dump_func)dump_create_timer_reply,
1351     (dump_func)dump_open_timer_reply,
1352     (dump_func)0,
1353     (dump_func)0,
1354     (dump_func)dump_get_thread_context_reply,
1355     (dump_func)0,
1356 };
1357
1358 static const char * const req_names[REQ_NB_REQUESTS] = {
1359     "new_process",
1360     "new_thread",
1361     "set_debug",
1362     "init_process",
1363     "init_process_done",
1364     "init_thread",
1365     "get_thread_buffer",
1366     "terminate_process",
1367     "terminate_thread",
1368     "get_process_info",
1369     "set_process_info",
1370     "get_thread_info",
1371     "set_thread_info",
1372     "suspend_thread",
1373     "resume_thread",
1374     "debugger",
1375     "queue_apc",
1376     "get_apcs",
1377     "close_handle",
1378     "get_handle_info",
1379     "set_handle_info",
1380     "dup_handle",
1381     "open_process",
1382     "select",
1383     "create_event",
1384     "event_op",
1385     "open_event",
1386     "create_mutex",
1387     "release_mutex",
1388     "open_mutex",
1389     "create_semaphore",
1390     "release_semaphore",
1391     "open_semaphore",
1392     "create_file",
1393     "alloc_file_handle",
1394     "get_read_fd",
1395     "get_write_fd",
1396     "set_file_pointer",
1397     "truncate_file",
1398     "set_file_time",
1399     "flush_file",
1400     "get_file_info",
1401     "lock_file",
1402     "unlock_file",
1403     "create_pipe",
1404     "create_socket",
1405     "accept_socket",
1406     "set_socket_event",
1407     "get_socket_event",
1408     "enable_socket_event",
1409     "alloc_console",
1410     "free_console",
1411     "open_console",
1412     "set_console_fd",
1413     "get_console_mode",
1414     "set_console_mode",
1415     "set_console_info",
1416     "get_console_info",
1417     "write_console_input",
1418     "read_console_input",
1419     "create_change_notification",
1420     "create_mapping",
1421     "open_mapping",
1422     "get_mapping_info",
1423     "create_device",
1424     "create_snapshot",
1425     "next_process",
1426     "wait_debug_event",
1427     "send_debug_event",
1428     "continue_debug_event",
1429     "debug_process",
1430     "read_process_memory",
1431     "write_process_memory",
1432     "create_key",
1433     "open_key",
1434     "delete_key",
1435     "close_key",
1436     "enum_key",
1437     "query_key_info",
1438     "set_key_value",
1439     "get_key_value",
1440     "enum_key_value",
1441     "delete_key_value",
1442     "load_registry",
1443     "save_registry",
1444     "set_registry_levels",
1445     "create_timer",
1446     "open_timer",
1447     "set_timer",
1448     "cancel_timer",
1449     "get_thread_context",
1450     "set_thread_context",
1451 };
1452
1453 /* ### make_requests end ### */
1454 /* Everything above this line is generated automatically by tools/make_requests */
1455
1456 void trace_request( enum request req, int fd )
1457 {
1458     current->last_req = req;
1459     if (req < REQ_NB_REQUESTS)
1460     {
1461         fprintf( stderr, "%08x: %s(", (unsigned int)current, req_names[req] );
1462         req_dumpers[req]( current->buffer );
1463     }
1464     else
1465         fprintf( stderr, "%08x: %d(", (unsigned int)current, req );
1466     if (fd != -1) fprintf( stderr, " ) fd=%d\n", fd );
1467     else fprintf( stderr, " )\n" );
1468 }
1469
1470 void trace_kill( struct thread *thread )
1471 {
1472     fprintf( stderr,"%08x: *killed* exit_code=%d\n",
1473              (unsigned int)thread, thread->exit_code );
1474 }
1475
1476 void trace_reply( struct thread *thread )
1477 {
1478     fprintf( stderr, "%08x: %s() = %d",
1479              (unsigned int)thread, req_names[thread->last_req], thread->error );
1480     if (reply_dumpers[thread->last_req])
1481     {
1482         fprintf( stderr, " {" );
1483         reply_dumpers[thread->last_req]( thread->buffer );
1484         fprintf( stderr, " }" );
1485     }
1486     if (thread->pass_fd != -1) fprintf( stderr, " fd=%d\n", thread->pass_fd );
1487     else fprintf( stderr, "\n" );
1488 }