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