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