server/trace.c

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