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 };
 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 /* fetch information about a thread */
 241 DECL_HANDLER(get_thread_info)
 242 {
 243     struct thread *thread;
 244     struct get_thread_info_reply reply = { 0, 0 };
 245
 246     if ((thread = get_thread_from_handle( req->handle, THREAD_QUERY_INFORMATION )))
 247     {
 248         get_thread_info( thread, &reply );
 249         release_object( thread );
 250     }
 251     send_reply( current, -1, 1, &reply, sizeof(reply) );
 252 }
 253
 254 /* open a handle to a process */
 255 DECL_HANDLER(open_process)
 256 {
 257     struct open_process_reply reply = { -1 };
 258     struct process *process = get_process_from_id( req->pid );
 259     if (process)
 260     {
 261         reply.handle = alloc_handle( current->process, process,
 262                                      req->access, req->inherit );
 263         release_object( process );
 264     }
 265     send_reply( current, -1, 1, &reply, sizeof(reply) );
 266 }
 267
 268 /* select on a handle list */
 269 DECL_HANDLER(select)
 270 {
 271     if (len != req->count * sizeof(int))
 272         fatal_protocol_error( "select: bad length %d for %d handles\n",
 273                               len, req->count );
 274     sleep_on( current, req->count, (int *)data, req->flags, req->timeout );
 275 }
 276
 277 /* create an event */
 278 DECL_HANDLER(create_event)
 279 {
 280     struct create_event_reply reply = { -1 };
 281     struct object *obj;
 282     char *name = (char *)data;
 283     if (!len) name = NULL;
 284     else CHECK_STRING( "create_event", name, len );
 285
 286     obj = create_event( name, req->manual_reset, req->initial_state );
 287     if (obj)
 288     {
 289         reply.handle = alloc_handle( current->process, obj, EVENT_ALL_ACCESS, req->inherit );
 290         release_object( obj );
 291     }
 292     send_reply( current, -1, 1, &reply, sizeof(reply) );
 293 }
 294
 295 /* do an event operation */
 296 DECL_HANDLER(event_op)
 297 {
 298     switch(req->op)
 299     {
 300     case PULSE_EVENT:
 301         pulse_event( req->handle );
 302         break;
 303     case SET_EVENT:
 304         set_event( req->handle );
 305         break;
 306     case RESET_EVENT:
 307         reset_event( req->handle );
 308         break;
 309     default:
 310         fatal_protocol_error( "event_op: invalid operation %d\n", req->op );
 311     }
 312     send_reply( current, -1, 0 );
 313 }
 314
 315 /* create a mutex */
 316 DECL_HANDLER(create_mutex)
 317 {
 318     struct create_mutex_reply reply = { -1 };
 319     struct object *obj;
 320     char *name = (char *)data;
 321     if (!len) name = NULL;
 322     else CHECK_STRING( "create_mutex", name, len );
 323
 324     obj = create_mutex( name, req->owned );
 325     if (obj)
 326     {
 327         reply.handle = alloc_handle( current->process, obj, MUTEX_ALL_ACCESS, req->inherit );
 328         release_object( obj );
 329     }
 330     send_reply( current, -1, 1, &reply, sizeof(reply) );
 331 }
 332
 333 /* release a mutex */
 334 DECL_HANDLER(release_mutex)
 335 {
 336     if (release_mutex( req->handle )) CLEAR_ERROR();
 337     send_reply( current, -1, 0 );
 338 }
 339
 340 /* create a semaphore */
 341 DECL_HANDLER(create_semaphore)
 342 {
 343     struct create_semaphore_reply reply = { -1 };
 344     struct object *obj;
 345     char *name = (char *)data;
 346     if (!len) name = NULL;
 347     else CHECK_STRING( "create_semaphore", name, len );
 348
 349     obj = create_semaphore( name, req->initial, req->max );
 350     if (obj)
 351     {
 352         reply.handle = alloc_handle( current->process, obj, SEMAPHORE_ALL_ACCESS, req->inherit );
 353         release_object( obj );
 354     }
 355     send_reply( current, -1, 1, &reply, sizeof(reply) );
 356 }
 357
 358 /* release a semaphore */
 359 DECL_HANDLER(release_semaphore)
 360 {
 361     struct release_semaphore_reply reply;
 362     if (release_semaphore( req->handle, req->count, &reply.prev_count )) CLEAR_ERROR();
 363     send_reply( current, -1, 1, &reply, sizeof(reply) );
 364 }
 365
 366 /* open a handle to a named object (event, mutex, semaphore) */
 367 DECL_HANDLER(open_named_obj)
 368 {
 369     struct open_named_obj_reply reply;
 370     char *name = (char *)data;
 371     if (!len) name = NULL;
 372     else CHECK_STRING( "open_named_obj", name, len );
 373
 374     switch(req->type)
 375     {
 376     case OPEN_EVENT:
 377         reply.handle = open_event( req->access, req->inherit, name );
 378         break;
 379     case OPEN_MUTEX:
 380         reply.handle = open_mutex( req->access, req->inherit, name );
 381         break;
 382     case OPEN_SEMAPHORE:
 383         reply.handle = open_semaphore( req->access, req->inherit, name );
 384         break;
 385     default:
 386         fatal_protocol_error( "open_named_obj: invalid type %d\n", req->type );
 387     }
 388     send_reply( current, -1, 1, &reply, sizeof(reply) );
 389 }
 390
 391 /* create a file */
 392 DECL_HANDLER(create_file)
 393 {
 394     struct create_file_reply reply = { -1 };
 395     struct object *obj;
 396     int new_fd;
 397
 398     if ((new_fd = dup(fd)) == -1)
 399     {
 400         SET_ERROR( ERROR_TOO_MANY_OPEN_FILES );
 401         goto done;
 402     }
 403     if ((obj = create_file( new_fd )) != NULL)
 404     {
 405         reply.handle = alloc_handle( current->process, obj, req->access, req->inherit );
 406         release_object( obj );
 407     }
 408  done:
 409     send_reply( current, -1, 1, &reply, sizeof(reply) );
 410 }
 411
 412 /* get a Unix handle to a file */
 413 DECL_HANDLER(get_unix_handle)
 414 {
 415     int handle = file_get_unix_handle( req->handle, req->access );
 416     send_reply( current, handle, 0 );
 417 }
 418
 419 /* get a Unix fd to read from a file */
 420 DECL_HANDLER(get_read_fd)
 421 {
 422     struct object *obj;
 423     int read_fd;
 424
 425     if ((obj = get_handle_obj( current->process, req->handle, GENERIC_READ, NULL )))
 426     {
 427         read_fd = obj->ops->get_read_fd( obj );
 428         release_object( obj );
 429     }
 430     else read_fd = -1;
 431     send_reply( current, read_fd, 0 );
 432 }
 433
 434 /* get a Unix fd to write to a file */
 435 DECL_HANDLER(get_write_fd)
 436 {
 437     struct object *obj;
 438     int write_fd;
 439
 440     if ((obj = get_handle_obj( current->process, req->handle, GENERIC_WRITE, NULL )))
 441     {
 442         write_fd = obj->ops->get_write_fd( obj );
 443         release_object( obj );
 444     }
 445     else write_fd = -1;
 446     send_reply( current, write_fd, 0 );
 447 }
 448
 449 /* set a file current position */
 450 DECL_HANDLER(set_file_pointer)
 451 {
 452     struct set_file_pointer_reply reply = { req->low, req->high };
 453     set_file_pointer( req->handle, &reply.low, &reply.high, req->whence );
 454     send_reply( current, -1, 1, &reply, sizeof(reply) );
 455 }
 456
 457 /* truncate (or extend) a file */
 458 DECL_HANDLER(truncate_file)
 459 {
 460     truncate_file( req->handle );
 461     send_reply( current, -1, 0 );
 462 }
 463
 464 /* flush a file buffers */
 465 DECL_HANDLER(flush_file)
 466 {
 467     struct object *obj;
 468
 469     if ((obj = get_handle_obj( current->process, req->handle, GENERIC_WRITE, NULL )))
 470     {
 471         obj->ops->flush( obj );
 472         release_object( obj );
 473     }
 474     send_reply( current, -1, 0 );
 475 }
 476
 477 /* get a file information */
 478 DECL_HANDLER(get_file_info)
 479 {
 480     struct get_file_info_reply reply;
 481     get_file_info( req->handle, &reply );
 482     send_reply( current, -1, 1, &reply, sizeof(reply) );
 483 }
 484
 485 /* create an anonymous pipe */
 486 DECL_HANDLER(create_pipe)
 487 {
 488     struct create_pipe_reply reply = { -1, -1 };
 489     struct object *obj[2];
 490     if (create_pipe( obj ))
 491     {
 492         reply.handle_read = alloc_handle( current->process, obj[0],
 493                                           STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|GENERIC_READ,
 494                                           req->inherit );
 495         if (reply.handle_read != -1)
 496         {
 497             reply.handle_write = alloc_handle( current->process, obj[1],
 498                                                STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|GENERIC_WRITE,
 499                                                req->inherit );
 500             if (reply.handle_write == -1)
 501                 close_handle( current->process, reply.handle_read );
 502         }
 503         release_object( obj[0] );
 504         release_object( obj[1] );
 505     }
 506     send_reply( current, -1, 1, &reply, sizeof(reply) );
 507 }
 508
 509 /* create a console */
 510 DECL_HANDLER(create_console)
 511 {
 512     struct create_console_reply reply = { -1, -1 };
 513     struct object *obj[2];
 514     if (create_console( fd, obj ))
 515     {
 516         reply.handle_read = alloc_handle( current->process, obj[0],
 517                                           STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|GENERIC_READ,
 518                                           req->inherit );
 519         if (reply.handle_read != -1)
 520         {
 521             reply.handle_write = alloc_handle( current->process, obj[1],
 522                                                STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|GENERIC_WRITE,
 523                                                req->inherit );
 524             if (reply.handle_write == -1)
 525                 close_handle( current->process, reply.handle_read );
 526         }
 527         release_object( obj[0] );
 528         release_object( obj[1] );
 529     }
 530     send_reply( current, -1, 1, &reply, sizeof(reply) );
 531 }
 532
 533 /* set a console fd */
 534 DECL_HANDLER(set_console_fd)
 535 {
 536     set_console_fd( req->handle, fd );
 537     send_reply( current, -1, 0 );
 538 }
 539
 540 /* create a change notification */
 541 DECL_HANDLER(create_change_notification)
 542 {
 543     struct object *obj;
 544     struct create_change_notification_reply reply = { -1 };
 545
 546     if ((obj = create_change_notification( req->subtree, req->filter )))
 547     {
 548         reply.handle = alloc_handle( current->process, obj,
 549                                      STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE, 0 );
 550         release_object( obj );
 551     }
 552     send_reply( current, -1, 1, &reply, sizeof(reply) );
 553 }
 554