server/request.c

   1 /*
   2  * Server-side request handling
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <stdarg.h>
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include <stdlib.h>
  12 #include <signal.h>
  13 #include <sys/types.h>
  14 #include <sys/uio.h>
  15 #include <unistd.h>
  16
  17 #include "winerror.h"
  18 #include "winnt.h"
  19 #include "winbase.h"
  20 #include "wincon.h"
  21 #define WANT_REQUEST_HANDLERS
  22 #include "server.h"
  23 #include "server/request.h"
  24 #include "server/process.h"
  25 #include "server/thread.h"
  26
  27 /* check that the string is NULL-terminated and that the len is correct */
  28 #define CHECK_STRING(func,str,len) \
  29   do { if (((str)[(len)-1] || strlen(str) != (len)-1)) \
  30          fatal_protocol_error( "%s: invalid string '%.*s'\n", (func), (len), (str) ); \
  31      } while(0)
  32
  33 struct thread *current = NULL;  /* thread handling the current request */
  34
  35 /* complain about a protocol error and terminate the client connection */
  36 static void fatal_protocol_error( const char *err, ... )
  37 {
  38     va_list args;
  39
  40     va_start( args, err );
  41     fprintf( stderr, "Protocol error:%p: ", current );
  42     vfprintf( stderr, err, args );
  43     va_end( args );
  44     remove_client( current->client_fd, -2 );
  45 }
  46
  47 /* call a request handler */
  48 void call_req_handler( struct thread *thread, enum request req,
  49                        void *data, int len, int fd )
  50 {
  51     const struct handler *handler = &req_handlers[req];
  52     char *ptr;
  53
  54     current = thread;
  55     if ((req < 0) || (req >= REQ_NB_REQUESTS))
  56     {
  57         fatal_protocol_error( "unknown request %d\n", req );
  58         return;
  59     }
  60
  61     if (len < handler->min_size)
  62     {
  63         fatal_protocol_error( "req %d bad length %d < %d)\n", req, len, handler->min_size );
  64         return;
  65     }
  66
  67     /* now call the handler */
  68     if (current)
  69     {
  70         CLEAR_ERROR();
  71         if (debug_level) trace_request( req, data, len, fd );
  72     }
  73     len -= handler->min_size;
  74     ptr = (char *)data + handler->min_size;
  75     handler->handler( data, ptr, len, fd );
  76     current = NULL;
  77 }
  78
  79 /* handle a client timeout (unused for now) */
  80 void call_timeout_handler( struct thread *thread )
  81 {
  82     current = thread;
  83     if (debug_level) trace_timeout();
  84     CLEAR_ERROR();
  85     thread_timeout();
  86     current = NULL;
  87 }
  88
  89 /* a thread has been killed */
  90 void call_kill_handler( struct thread *thread, int exit_code )
  91 {
  92     /* must be reentrant WRT call_req_handler */
  93     struct thread *old_current = current;
  94     current = thread;
  95     if (current)
  96     {
  97         if (debug_level) trace_kill( exit_code );
  98         thread_killed( current, exit_code );
  99     }
 100     current = (old_current != thread) ? old_current : NULL;
 101 }
 102
 103
 104 /* create a new process */
 105 DECL_HANDLER(new_process)
 106 {
 107     struct new_process_reply reply;
 108     struct process *process;
 109
 110     if ((process = create_process( req )))
 111     {
 112         reply.pid    = process;
 113         reply.handle = alloc_handle( current->process, process,
 114                                      PROCESS_ALL_ACCESS, req->inherit );
 115         release_object( process );
 116     }
 117     else
 118     {
 119         reply.handle = -1;
 120         reply.pid    = NULL;
 121     }
 122     send_reply( current, -1, 1, &reply, sizeof(reply) );
 123 }
 124
 125 /* create a new thread */
 126 DECL_HANDLER(new_thread)
 127 {
 128     struct new_thread_reply reply;
 129     int new_fd;
 130
 131     if ((new_fd = dup(fd)) != -1)
 132     {
 133         reply.tid = create_thread( new_fd, req->pid, req->suspend,
 134                                    req->inherit, &reply.handle );
 135         if (!reply.tid) close( new_fd );
 136     }
 137     else
 138         SET_ERROR( ERROR_TOO_MANY_OPEN_FILES );
 139
 140     send_reply( current, -1, 1, &reply, sizeof(reply) );
 141 }
 142
 143 /* initialize a new process */
 144 DECL_HANDLER(init_process)
 145 {
 146     struct init_process_reply reply;
 147     if (current->state != RUNNING)
 148     {
 149         fatal_protocol_error( "init_process: init_thread not called yet\n" );
 150         return;
 151     }
 152     if (!get_process_init_info( current->process, &reply ))
 153     {
 154         fatal_protocol_error( "init_process: called twice\n" );
 155         return;
 156     }
 157     send_reply( current, -1, 1, &reply, sizeof(reply) );
 158 }
 159
 160 /* initialize a new thread */
 161 DECL_HANDLER(init_thread)
 162 {
 163     struct init_thread_reply reply;
 164
 165     if (current->state != STARTING)
 166     {
 167         fatal_protocol_error( "init_thread: already running\n" );
 168         return;
 169     }
 170     current->state    = RUNNING;
 171     current->unix_pid = req->unix_pid;
 172     if (current->suspend > 0)
 173         kill( current->unix_pid, SIGSTOP );
 174     reply.pid = current->process;
 175     reply.tid = current;
 176     send_reply( current, -1, 1, &reply, sizeof(reply) );
 177 }
 178
 179 /* set the debug level */
 180 DECL_HANDLER(set_debug)
 181 {
 182     debug_level = req->level;
 183     /* Make sure last_req is initialized */
 184     current->last_req = REQ_SET_DEBUG;
 185     CLEAR_ERROR();
 186     send_reply( current, -1, 0 );
 187 }
 188
 189 /* terminate a process */
 190 DECL_HANDLER(terminate_process)
 191 {
 192     struct process *process;
 193
 194     if ((process = get_process_from_handle( req->handle, PROCESS_TERMINATE )))
 195     {
 196         kill_process( process, req->exit_code );
 197         release_object( process );
 198     }
 199     if (current) send_reply( current, -1, 0 );
 200 }
 201
 202 /* terminate a thread */
 203 DECL_HANDLER(terminate_thread)
 204 {
 205     struct thread *thread;
 206
 207     if ((thread = get_thread_from_handle( req->handle, THREAD_TERMINATE )))
 208     {
 209         kill_thread( thread, req->exit_code );
 210         release_object( thread );
 211     }
 212     if (current) send_reply( current, -1, 0 );
 213 }
 214
 215 /* close a handle */
 216 DECL_HANDLER(close_handle)
 217 {
 218     close_handle( current->process, req->handle );
 219     send_reply( current, -1, 0 );
 220 }
 221
 222 /* get information about a handle */
 223 DECL_HANDLER(get_handle_info)
 224 {
 225     struct get_handle_info_reply reply;
 226     reply.flags = set_handle_info( current->process, req->handle, 0, 0 );
 227     send_reply( current, -1, 1, &reply, sizeof(reply) );
 228 }
 229
 230 /* set a handle information */
 231 DECL_HANDLER(set_handle_info)
 232 {
 233     set_handle_info( current->process, req->handle, req->mask, req->flags );
 234     send_reply( current, -1, 0 );
 235 }
 236
 237 /* duplicate a handle */
 238 DECL_HANDLER(dup_handle)
 239 {
 240     struct dup_handle_reply reply = { -1 };
 241     struct process *src, *dst;
 242
 243     if ((src = get_process_from_handle( req->src_process, PROCESS_DUP_HANDLE )))
 244     {
 245         if (req->options & DUP_HANDLE_MAKE_GLOBAL)
 246         {
 247             reply.handle = duplicate_handle( src, req->src_handle, NULL,
 248                                              req->access, req->inherit, req->options );
 249         }
 250         else if ((dst = get_process_from_handle( req->dst_process, PROCESS_DUP_HANDLE )))
 251         {
 252             reply.handle = duplicate_handle( src, req->src_handle, dst,
 253                                              req->access, req->inherit, req->options );
 254             release_object( dst );
 255         }
 256         /* close the handle no matter what happened */
 257         if (req->options & DUP_HANDLE_CLOSE_SOURCE)
 258             close_handle( src, req->src_handle );
 259         release_object( src );
 260     }
 261     send_reply( current, -1, 1, &reply, sizeof(reply) );
 262 }
 263
 264 /* fetch information about a process */
 265 DECL_HANDLER(get_process_info)
 266 {
 267     struct process *process;
 268     struct get_process_info_reply reply = { 0, 0, 0 };
 269
 270     if ((process = get_process_from_handle( req->handle, PROCESS_QUERY_INFORMATION )))
 271     {
 272         get_process_info( process, &reply );
 273         release_object( process );
 274     }
 275     send_reply( current, -1, 1, &reply, sizeof(reply) );
 276 }
 277
 278 /* set information about a process */
 279 DECL_HANDLER(set_process_info)
 280 {
 281     struct process *process;
 282
 283     if ((process = get_process_from_handle( req->handle, PROCESS_SET_INFORMATION )))
 284     {
 285         set_process_info( process, req );
 286         release_object( process );
 287     }
 288     send_reply( current, -1, 0 );
 289 }
 290
 291 /* fetch information about a thread */
 292 DECL_HANDLER(get_thread_info)
 293 {
 294     struct thread *thread;
 295     struct get_thread_info_reply reply = { 0, 0 };
 296
 297     if ((thread = get_thread_from_handle( req->handle, THREAD_QUERY_INFORMATION )))
 298     {
 299         get_thread_info( thread, &reply );
 300         release_object( thread );
 301     }
 302     send_reply( current, -1, 1, &reply, sizeof(reply) );
 303 }
 304
 305 /* set information about a thread */
 306 DECL_HANDLER(set_thread_info)
 307 {
 308     struct thread *thread;
 309
 310     if ((thread = get_thread_from_handle( req->handle, THREAD_SET_INFORMATION )))
 311     {
 312         set_thread_info( thread, req );
 313         release_object( thread );
 314     }
 315     send_reply( current, -1, 0 );
 316 }
 317
 318 /* debugger support operations */
 319 DECL_HANDLER(debugger)
 320 {
 321     switch ( req->op )
 322     {
 323     case DEBUGGER_FREEZE_ALL:
 324         suspend_all_threads();
 325         break;
 326
 327     case DEBUGGER_UNFREEZE_ALL:
 328         resume_all_threads();
 329         break;
 330     }
 331
 332     send_reply( current, -1, 0 );
 333 }
 334
 335 /* suspend a thread */
 336 DECL_HANDLER(suspend_thread)
 337 {
 338     struct thread *thread;
 339     struct suspend_thread_reply reply = { -1 };
 340     if ((thread = get_thread_from_handle( req->handle, THREAD_SUSPEND_RESUME )))
 341     {
 342         reply.count = suspend_thread( thread );
 343         release_object( thread );
 344     }
 345     send_reply( current, -1, 1, &reply, sizeof(reply) );
 346
 347 }
 348
 349 /* resume a thread */
 350 DECL_HANDLER(resume_thread)
 351 {
 352     struct thread *thread;
 353     struct resume_thread_reply reply = { -1 };
 354     if ((thread = get_thread_from_handle( req->handle, THREAD_SUSPEND_RESUME )))
 355     {
 356         reply.count = resume_thread( thread );
 357         release_object( thread );
 358     }
 359     send_reply( current, -1, 1, &reply, sizeof(reply) );
 360
 361 }
 362
 363 /* queue an APC for a thread */
 364 DECL_HANDLER(queue_apc)
 365 {
 366     struct thread *thread;
 367     if ((thread = get_thread_from_handle( req->handle, THREAD_SET_CONTEXT )))
 368     {
 369         thread_queue_apc( thread, req->func, req->param );
 370         release_object( thread );
 371     }
 372     send_reply( current, -1, 0 );
 373 }
 374
 375 /* open a handle to a process */
 376 DECL_HANDLER(open_process)
 377 {
 378     struct open_process_reply reply = { -1 };
 379     struct process *process = get_process_from_id( req->pid );
 380     if (process)
 381     {
 382         reply.handle = alloc_handle( current->process, process,
 383                                      req->access, req->inherit );
 384         release_object( process );
 385     }
 386     send_reply( current, -1, 1, &reply, sizeof(reply) );
 387 }
 388
 389 /* select on a handle list */
 390 DECL_HANDLER(select)
 391 {
 392     if (len != req->count * sizeof(int))
 393         fatal_protocol_error( "select: bad length %d for %d handles\n",
 394                               len, req->count );
 395     sleep_on( current, req->count, (int *)data, req->flags, req->timeout );
 396 }
 397
 398 /* create an event */
 399 DECL_HANDLER(create_event)
 400 {
 401     struct create_event_reply reply = { -1 };
 402     struct object *obj;
 403     char *name = (char *)data;
 404     if (!len) name = NULL;
 405     else CHECK_STRING( "create_event", name, len );
 406
 407     obj = create_event( name, req->manual_reset, req->initial_state );
 408     if (obj)
 409     {
 410         reply.handle = alloc_handle( current->process, obj, EVENT_ALL_ACCESS, req->inherit );
 411         release_object( obj );
 412     }
 413     send_reply( current, -1, 1, &reply, sizeof(reply) );
 414 }
 415
 416 /* do an event operation */
 417 DECL_HANDLER(event_op)
 418 {
 419     switch(req->op)
 420     {
 421     case PULSE_EVENT:
 422         pulse_event( req->handle );
 423         break;
 424     case SET_EVENT:
 425         set_event( req->handle );
 426         break;
 427     case RESET_EVENT:
 428         reset_event( req->handle );
 429         break;
 430     default:
 431         fatal_protocol_error( "event_op: invalid operation %d\n", req->op );
 432     }
 433     send_reply( current, -1, 0 );
 434 }
 435
 436 /* create a mutex */
 437 DECL_HANDLER(create_mutex)
 438 {
 439     struct create_mutex_reply reply = { -1 };
 440     struct object *obj;
 441     char *name = (char *)data;
 442     if (!len) name = NULL;
 443     else CHECK_STRING( "create_mutex", name, len );
 444
 445     obj = create_mutex( name, req->owned );
 446     if (obj)
 447     {
 448         reply.handle = alloc_handle( current->process, obj, MUTEX_ALL_ACCESS, req->inherit );
 449         release_object( obj );
 450     }
 451     send_reply( current, -1, 1, &reply, sizeof(reply) );
 452 }
 453
 454 /* release a mutex */
 455 DECL_HANDLER(release_mutex)
 456 {
 457     if (release_mutex( req->handle )) CLEAR_ERROR();
 458     send_reply( current, -1, 0 );
 459 }
 460
 461 /* create a semaphore */
 462 DECL_HANDLER(create_semaphore)
 463 {
 464     struct create_semaphore_reply reply = { -1 };
 465     struct object *obj;
 466     char *name = (char *)data;
 467     if (!len) name = NULL;
 468     else CHECK_STRING( "create_semaphore", name, len );
 469
 470     obj = create_semaphore( name, req->initial, req->max );
 471     if (obj)
 472     {
 473         reply.handle = alloc_handle( current->process, obj, SEMAPHORE_ALL_ACCESS, req->inherit );
 474         release_object( obj );
 475     }
 476     send_reply( current, -1, 1, &reply, sizeof(reply) );
 477 }
 478
 479 /* release a semaphore */
 480 DECL_HANDLER(release_semaphore)
 481 {
 482     struct release_semaphore_reply reply;
 483     if (release_semaphore( req->handle, req->count, &reply.prev_count )) CLEAR_ERROR();
 484     send_reply( current, -1, 1, &reply, sizeof(reply) );
 485 }
 486
 487 /* open a handle to a named object (event, mutex, semaphore) */
 488 DECL_HANDLER(open_named_obj)
 489 {
 490     struct open_named_obj_reply reply;
 491     char *name = (char *)data;
 492     if (!len) name = NULL;
 493     else CHECK_STRING( "open_named_obj", name, len );
 494
 495     switch(req->type)
 496     {
 497     case OPEN_EVENT:
 498         reply.handle = open_event( req->access, req->inherit, name );
 499         break;
 500     case OPEN_MUTEX:
 501         reply.handle = open_mutex( req->access, req->inherit, name );
 502         break;
 503     case OPEN_SEMAPHORE:
 504         reply.handle = open_semaphore( req->access, req->inherit, name );
 505         break;
 506     case OPEN_MAPPING:
 507         reply.handle = open_mapping( req->access, req->inherit, name );
 508         break;
 509     default:
 510         fatal_protocol_error( "open_named_obj: invalid type %d\n", req->type );
 511     }
 512     send_reply( current, -1, 1, &reply, sizeof(reply) );
 513 }
 514
 515 /* create a file */
 516 DECL_HANDLER(create_file)
 517 {
 518     struct create_file_reply reply = { -1 };
 519     struct object *obj;
 520     char *name = (char *)data;
 521     if (!len) name = NULL;
 522     else CHECK_STRING( "create_file", name, len );
 523
 524     if ((obj = create_file( fd, name, req->access,
 525                             req->sharing, req->create, req->attrs )) != NULL)
 526     {
 527         reply.handle = alloc_handle( current->process, obj, req->access, req->inherit );
 528         release_object( obj );
 529     }
 530     send_reply( current, -1, 1, &reply, sizeof(reply) );
 531 }
 532
 533 /* get a Unix fd to read from a file */
 534 DECL_HANDLER(get_read_fd)
 535 {
 536     struct object *obj;
 537     int read_fd;
 538
 539     if ((obj = get_handle_obj( current->process, req->handle, GENERIC_READ, NULL )))
 540     {
 541         read_fd = obj->ops->get_read_fd( obj );
 542         release_object( obj );
 543     }
 544     else read_fd = -1;
 545     send_reply( current, read_fd, 0 );
 546 }
 547
 548 /* get a Unix fd to write to a file */
 549 DECL_HANDLER(get_write_fd)
 550 {
 551     struct object *obj;
 552     int write_fd;
 553
 554     if ((obj = get_handle_obj( current->process, req->handle, GENERIC_WRITE, NULL )))
 555     {
 556         write_fd = obj->ops->get_write_fd( obj );
 557         release_object( obj );
 558     }
 559     else write_fd = -1;
 560     send_reply( current, write_fd, 0 );
 561 }
 562
 563 /* set a file current position */
 564 DECL_HANDLER(set_file_pointer)
 565 {
 566     struct set_file_pointer_reply reply;
 567     reply.low = req->low;
 568     reply.high = req->high;
 569     set_file_pointer( req->handle, &reply.low, &reply.high, req->whence );
 570     send_reply( current, -1, 1, &reply, sizeof(reply) );
 571 }
 572
 573 /* truncate (or extend) a file */
 574 DECL_HANDLER(truncate_file)
 575 {
 576     truncate_file( req->handle );
 577     send_reply( current, -1, 0 );
 578 }
 579
 580 /* flush a file buffers */
 581 DECL_HANDLER(flush_file)
 582 {
 583     struct object *obj;
 584
 585     if ((obj = get_handle_obj( current->process, req->handle, GENERIC_WRITE, NULL )))
 586     {
 587         obj->ops->flush( obj );
 588         release_object( obj );
 589     }
 590     send_reply( current, -1, 0 );
 591 }
 592
 593 /* set a file access and modification times */
 594 DECL_HANDLER(set_file_time)
 595 {
 596     set_file_time( req->handle, req->access_time, req->write_time );
 597     send_reply( current, -1, 0 );
 598 }
 599
 600 /* get a file information */
 601 DECL_HANDLER(get_file_info)
 602 {
 603     struct object *obj;
 604     struct get_file_info_reply reply;
 605
 606     if ((obj = get_handle_obj( current->process, req->handle, 0, NULL )))
 607     {
 608         obj->ops->get_file_info( obj, &reply );
 609         release_object( obj );
 610     }
 611     send_reply( current, -1, 1, &reply, sizeof(reply) );
 612 }
 613
 614 /* lock a region of a file */
 615 DECL_HANDLER(lock_file)
 616 {
 617     struct file *file;
 618
 619     if ((file = get_file_obj( current->process, req->handle, 0 )))
 620     {
 621         file_lock( file, req->offset_high, req->offset_low,
 622                    req->count_high, req->count_low );
 623         release_object( file );
 624     }
 625     send_reply( current, -1, 0 );
 626 }
 627
 628
 629 /* unlock a region of a file */
 630 DECL_HANDLER(unlock_file)
 631 {
 632     struct file *file;
 633
 634     if ((file = get_file_obj( current->process, req->handle, 0 )))
 635     {
 636         file_unlock( file, req->offset_high, req->offset_low,
 637                      req->count_high, req->count_low );
 638         release_object( file );
 639     }
 640     send_reply( current, -1, 0 );
 641 }
 642
 643
 644 /* create an anonymous pipe */
 645 DECL_HANDLER(create_pipe)
 646 {
 647     struct create_pipe_reply reply = { -1, -1 };
 648     struct object *obj[2];
 649     if (create_pipe( obj ))
 650     {
 651         reply.handle_read = alloc_handle( current->process, obj[0],
 652                                           STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|GENERIC_READ,
 653                                           req->inherit );
 654         if (reply.handle_read != -1)
 655         {
 656             reply.handle_write = alloc_handle( current->process, obj[1],
 657                                                STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|GENERIC_WRITE,
 658                                                req->inherit );
 659             if (reply.handle_write == -1)
 660                 close_handle( current->process, reply.handle_read );
 661         }
 662         release_object( obj[0] );
 663         release_object( obj[1] );
 664     }
 665     send_reply( current, -1, 1, &reply, sizeof(reply) );
 666 }
 667
 668 /* allocate a console for the current process */
 669 DECL_HANDLER(alloc_console)
 670 {
 671     alloc_console( current->process );
 672     send_reply( current, -1, 0 );
 673 }
 674
 675 /* free the console of the current process */
 676 DECL_HANDLER(free_console)
 677 {
 678     free_console( current->process );
 679     send_reply( current, -1, 0 );
 680 }
 681
 682 /* open a handle to the process console */
 683 DECL_HANDLER(open_console)
 684 {
 685     struct object *obj;
 686     struct open_console_reply reply = { -1 };
 687     if ((obj = get_console( current->process, req->output )))
 688     {
 689         reply.handle = alloc_handle( current->process, obj, req->access, req->inherit );
 690         release_object( obj );
 691     }
 692     send_reply( current, -1, 1, &reply, sizeof(reply) );
 693 }
 694
 695 /* set info about a console (output only) */
 696 DECL_HANDLER(set_console_info)
 697 {
 698     char *name = (char *)data;
 699     if (!len) name = NULL;
 700     else CHECK_STRING( "set_console_info", name, len );
 701     set_console_info( req->handle, req, name );
 702     send_reply( current, -1, 0 );
 703 }
 704
 705 /* get info about a console (output only) */
 706 DECL_HANDLER(get_console_info)
 707 {
 708     struct get_console_info_reply reply;
 709     const char *title;
 710     get_console_info( req->handle, &reply, &title );
 711     send_reply( current, -1, 2, &reply, sizeof(reply),
 712                 title, title ? strlen(title)+1 : 0 );
 713 }
 714
 715 /* set a console fd */
 716 DECL_HANDLER(set_console_fd)
 717 {
 718     set_console_fd( req->handle, fd, req->pid );
 719     send_reply( current, -1, 0 );
 720 }
 721
 722 /* get a console mode (input or output) */
 723 DECL_HANDLER(get_console_mode)
 724 {
 725     struct get_console_mode_reply reply;
 726     get_console_mode( req->handle, &reply.mode );
 727     send_reply( current, -1, 1, &reply, sizeof(reply) );
 728 }
 729
 730 /* set a console mode (input or output) */
 731 DECL_HANDLER(set_console_mode)
 732 {
 733     set_console_mode( req->handle, req->mode );
 734     send_reply( current, -1, 0 );
 735 }
 736
 737 /* add input records to a console input queue */
 738 DECL_HANDLER(write_console_input)
 739 {
 740     struct write_console_input_reply reply;
 741     INPUT_RECORD *records = (INPUT_RECORD *)data;
 742
 743     if (len != req->count * sizeof(INPUT_RECORD))
 744         fatal_protocol_error( "write_console_input: bad length %d for %d records\n",
 745                               len, req->count );
 746     reply.written = write_console_input( req->handle, req->count, records );
 747     send_reply( current, -1, 1, &reply, sizeof(reply) );
 748 }
 749
 750 /* fetch input records from a console input queue */
 751 DECL_HANDLER(read_console_input)
 752 {
 753     read_console_input( req->handle, req->count, req->flush );
 754 }
 755
 756 /* create a change notification */
 757 DECL_HANDLER(create_change_notification)
 758 {
 759     struct object *obj;
 760     struct create_change_notification_reply reply = { -1 };
 761
 762     if ((obj = create_change_notification( req->subtree, req->filter )))
 763     {
 764         reply.handle = alloc_handle( current->process, obj,
 765                                      STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE, 0 );
 766         release_object( obj );
 767     }
 768     send_reply( current, -1, 1, &reply, sizeof(reply) );
 769 }
 770
 771 /* create a file mapping */
 772 DECL_HANDLER(create_mapping)
 773 {
 774     struct object *obj;
 775     struct create_mapping_reply reply = { -1 };
 776     char *name = (char *)data;
 777     if (!len) name = NULL;
 778     else CHECK_STRING( "create_mapping", name, len );
 779
 780     if ((obj = create_mapping( req->size_high, req->size_low,
 781                                req->protect, req->handle, name )))
 782     {
 783         int access = FILE_MAP_ALL_ACCESS;
 784         if (!(req->protect & VPROT_WRITE)) access &= ~FILE_MAP_WRITE;
 785         reply.handle = alloc_handle( current->process, obj, access, req->inherit );
 786         release_object( obj );
 787     }
 788     send_reply( current, -1, 1, &reply, sizeof(reply) );
 789 }
 790
 791 /* get a mapping information */
 792 DECL_HANDLER(get_mapping_info)
 793 {
 794     struct get_mapping_info_reply reply;
 795     int map_fd = get_mapping_info( req->handle, &reply );
 796     send_reply( current, map_fd, 1, &reply, sizeof(reply) );
 797 }
 798
 799 /* create a device */
 800 DECL_HANDLER(create_device)
 801 {
 802     struct object *obj;
 803     struct create_device_reply reply = { -1 };
 804
 805     if ((obj = create_device( req->id )))
 806     {
 807         reply.handle = alloc_handle( current->process, obj,
 808                                      req->access, req->inherit );
 809         release_object( obj );
 810     }
 811     send_reply( current, -1, 1, &reply, sizeof(reply) );
 812 }
 813
 814 /* create a snapshot */
 815 DECL_HANDLER(create_snapshot)
 816 {
 817     struct object *obj;
 818     struct create_snapshot_reply reply = { -1 };
 819
 820     if ((obj = create_snapshot( req->flags )))
 821     {
 822         reply.handle = alloc_handle( current->process, obj, 0, req->inherit );
 823         release_object( obj );
 824     }
 825     send_reply( current, -1, 1, &reply, sizeof(reply) );
 826 }
 827
 828 /* get the next process from a snapshot */
 829 DECL_HANDLER(next_process)
 830 {
 831     struct next_process_reply reply;
 832     snapshot_next_process( req->handle, req->reset, &reply );
 833     send_reply( current, -1, 1, &reply, sizeof(reply) );
 834 }
 835