server/request.c

   1 /*
   2  * Server-side request handling
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  */
   6
   7 #include "config.h"
   8
   9 #include <assert.h>
  10 #include <errno.h>
  11 #include <fcntl.h>
  12 #include <pwd.h>
  13 #include <signal.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <stdarg.h>
  17 #include <string.h>
  18 #include <sys/stat.h>
  19 #include <sys/time.h>
  20 #include <sys/types.h>
  21 #ifdef HAVE_SYS_SOCKET_H
  22 # include <sys/socket.h>
  23 #endif
  24 #include <sys/uio.h>
  25 #include <sys/un.h>
  26 #include <unistd.h>
  27
  28 #include "winnt.h"
  29 #include "winbase.h"
  30 #include "wincon.h"
  31 #include "thread.h"
  32 #include "process.h"
  33 #define WANT_REQUEST_HANDLERS
  34 #include "request.h"
  35 #include "wine/port.h"
  36
  37 /* Some versions of glibc don't define this */
  38 #ifndef SCM_RIGHTS
  39 #define SCM_RIGHTS 1
  40 #endif
  41
  42  /* path names for server master Unix socket */
  43 #define CONFDIR    "/.wine"        /* directory for Wine config relative to $HOME */
  44 #define SERVERDIR  "wineserver-"   /* server socket directory (hostname appended) */
  45 #define SOCKETNAME "socket"        /* name of the socket file */
  46
  47 struct master_socket
  48 {
  49     struct object       obj;         /* object header */
  50 };
  51
  52 static void master_socket_dump( struct object *obj, int verbose );
  53 static void master_socket_poll_event( struct object *obj, int event );
  54 static void master_socket_destroy( struct object *obj );
  55
  56 static const struct object_ops master_socket_ops =
  57 {
  58     sizeof(struct master_socket),  /* size */
  59     master_socket_dump,            /* dump */
  60     no_add_queue,                  /* add_queue */
  61     NULL,                          /* remove_queue */
  62     NULL,                          /* signaled */
  63     NULL,                          /* satisfied */
  64     NULL,                          /* get_poll_events */
  65     master_socket_poll_event,      /* poll_event */
  66     no_get_fd,                     /* get_fd */
  67     no_flush,                      /* flush */
  68     no_get_file_info,              /* get_file_info */
  69     master_socket_destroy          /* destroy */
  70 };
  71
  72
  73 struct thread *current = NULL;  /* thread handling the current request */
  74 unsigned int global_error = 0;  /* global error code for when no thread is current */
  75
  76 static struct master_socket *master_socket;  /* the master socket object */
  77
  78 /* socket communication static structures */
  79 static struct iovec myiovec;
  80 static struct msghdr msghdr;
  81 #ifndef HAVE_MSGHDR_ACCRIGHTS
  82 struct cmsg_fd
  83 {
  84     int len;   /* sizeof structure */
  85     int level; /* SOL_SOCKET */
  86     int type;  /* SCM_RIGHTS */
  87     int fd;    /* fd to pass */
  88 };
  89 static struct cmsg_fd cmsg = { sizeof(cmsg), SOL_SOCKET, SCM_RIGHTS, -1 };
  90 #endif  /* HAVE_MSGHDR_ACCRIGHTS */
  91
  92 /* complain about a protocol error and terminate the client connection */
  93 void fatal_protocol_error( struct thread *thread, const char *err, ... )
  94 {
  95     va_list args;
  96
  97     va_start( args, err );
  98     fprintf( stderr, "Protocol error:%p: ", thread );
  99     vfprintf( stderr, err, args );
 100     va_end( args );
 101     thread->exit_code = 1;
 102     kill_thread( thread, 1 );
 103 }
 104
 105 /* complain about a protocol error and terminate the client connection */
 106 void fatal_protocol_perror( struct thread *thread, const char *err, ... )
 107 {
 108     va_list args;
 109
 110     va_start( args, err );
 111     fprintf( stderr, "Protocol error:%p: ", thread );
 112     vfprintf( stderr, err, args );
 113     perror( " " );
 114     va_end( args );
 115     thread->exit_code = 1;
 116     kill_thread( thread, 1 );
 117 }
 118
 119 /* die on a fatal error */
 120 void fatal_error( const char *err, ... )
 121 {
 122     va_list args;
 123
 124     va_start( args, err );
 125     fprintf( stderr, "wineserver: " );
 126     vfprintf( stderr, err, args );
 127     va_end( args );
 128     exit(1);
 129 }
 130
 131 /* die on a fatal error */
 132 void fatal_perror( const char *err, ... )
 133 {
 134     va_list args;
 135
 136     va_start( args, err );
 137     fprintf( stderr, "wineserver: " );
 138     vfprintf( stderr, err, args );
 139     perror( " " );
 140     va_end( args );
 141     exit(1);
 142 }
 143
 144 /* call a request handler */
 145 static inline void call_req_handler( struct thread *thread, union generic_request *request )
 146 {
 147     enum request req = request->header.req;
 148
 149     current = thread;
 150     clear_error();
 151
 152     if (debug_level) trace_request( thread, request );
 153
 154     if (request->header.var_size)
 155     {
 156         if ((unsigned int)request->header.var_offset +
 157                           request->header.var_size > MAX_REQUEST_LENGTH)
 158         {
 159             fatal_protocol_error( current, "bad request offset/size %d/%d\n",
 160                                   request->header.var_offset, request->header.var_size );
 161             return;
 162         }
 163     }
 164
 165     if (req < REQ_NB_REQUESTS)
 166     {
 167         req_handlers[req]( request );
 168         if (current) send_reply( current, request );
 169         current = NULL;
 170         return;
 171     }
 172     fatal_protocol_error( current, "bad request %d\n", req );
 173 }
 174
 175 /* read a request from a thread */
 176 void read_request( struct thread *thread )
 177 {
 178     union generic_request req;
 179     int ret;
 180
 181     if ((ret = read( thread->obj.fd, &req, sizeof(req) )) == sizeof(req))
 182     {
 183         call_req_handler( thread, &req );
 184         return;
 185     }
 186     if (!ret)  /* closed pipe */
 187         kill_thread( thread, 0 );
 188     else if (ret > 0)
 189         fatal_protocol_error( thread, "partial read %d\n", ret );
 190     else if (errno != EWOULDBLOCK && errno != EAGAIN)
 191         fatal_protocol_perror( thread, "read" );
 192 }
 193
 194 /* send a reply to a thread */
 195 void send_reply( struct thread *thread, union generic_request *request )
 196 {
 197     int ret;
 198
 199     if (debug_level) trace_reply( thread, request );
 200
 201     request->header.error = thread->error;
 202
 203     if ((ret = write( thread->reply_fd, request, sizeof(*request) )) != sizeof(*request))
 204     {
 205         if (ret >= 0)
 206             fatal_protocol_error( thread, "partial write %d\n", ret );
 207         else if (errno == EPIPE)
 208             kill_thread( thread, 0 );  /* normal death */
 209         else
 210             fatal_protocol_perror( thread, "reply write" );
 211     }
 212 }
 213
 214 /* receive a file descriptor on the process socket */
 215 int receive_fd( struct process *process )
 216 {
 217     struct send_fd data;
 218     int fd, ret;
 219
 220 #ifdef HAVE_MSGHDR_ACCRIGHTS
 221     msghdr.msg_accrightslen = sizeof(int);
 222     msghdr.msg_accrights = (void *)&fd;
 223 #else  /* HAVE_MSGHDR_ACCRIGHTS */
 224     msghdr.msg_control    = &cmsg;
 225     msghdr.msg_controllen = sizeof(cmsg);
 226     cmsg.fd = -1;
 227 #endif  /* HAVE_MSGHDR_ACCRIGHTS */
 228
 229     myiovec.iov_base = &data;
 230     myiovec.iov_len  = sizeof(data);
 231
 232     ret = recvmsg( process->obj.fd, &msghdr, 0 );
 233 #ifndef HAVE_MSGHDR_ACCRIGHTS
 234     fd = cmsg.fd;
 235 #endif
 236
 237     if (ret == sizeof(data))
 238     {
 239         struct thread *thread;
 240
 241         if (data.tid) thread = get_thread_from_id( data.tid );
 242         else thread = (struct thread *)grab_object( process->thread_list );
 243
 244         if (!thread || thread->process != process)
 245         {
 246             if (debug_level)
 247                 fprintf( stderr, "%08x: *fd* %d <- %d bad thread id\n",
 248                          (unsigned int)data.tid, data.fd, fd );
 249             close( fd );
 250         }
 251         else
 252         {
 253             if (debug_level)
 254                 fprintf( stderr, "%08x: *fd* %d <- %d\n",
 255                          (unsigned int)thread, data.fd, fd );
 256             thread_add_inflight_fd( thread, data.fd, fd );
 257         }
 258         if (thread) release_object( thread );
 259         return 0;
 260     }
 261
 262     if (ret >= 0)
 263     {
 264         if (ret > 0)
 265             fprintf( stderr, "Protocol error: process %p: partial recvmsg %d for fd\n",
 266                      process, ret );
 267         kill_process( process, NULL, 1 );
 268     }
 269     else
 270     {
 271         if (errno != EWOULDBLOCK && errno != EAGAIN)
 272         {
 273             fprintf( stderr, "Protocol error: process %p: ", process );
 274             perror( "recvmsg" );
 275             kill_process( process, NULL, 1 );
 276         }
 277     }
 278     return -1;
 279 }
 280
 281 /* send an fd to a client */
 282 int send_client_fd( struct process *process, int fd, handle_t handle )
 283 {
 284     int ret;
 285
 286     if (debug_level)
 287         fprintf( stderr, "%08x: *fd* %d -> %d\n", (unsigned int)current, handle, fd );
 288
 289 #ifdef HAVE_MSGHDR_ACCRIGHTS
 290     msghdr.msg_accrightslen = sizeof(fd);
 291     msghdr.msg_accrights = (void *)&fd;
 292 #else  /* HAVE_MSGHDR_ACCRIGHTS */
 293     msghdr.msg_control    = &cmsg;
 294     msghdr.msg_controllen = sizeof(cmsg);
 295     cmsg.fd = fd;
 296 #endif  /* HAVE_MSGHDR_ACCRIGHTS */
 297
 298     myiovec.iov_base = (void *)&handle;
 299     myiovec.iov_len  = sizeof(handle);
 300
 301     ret = sendmsg( process->obj.fd, &msghdr, 0 );
 302
 303     if (ret == sizeof(handle)) return 0;
 304
 305     if (ret >= 0)
 306     {
 307         if (ret > 0)
 308             fprintf( stderr, "Protocol error: process %p: partial sendmsg %d\n", process, ret );
 309         kill_process( process, NULL, 1 );
 310     }
 311     else
 312     {
 313         fprintf( stderr, "Protocol error: process %p: ", process );
 314         perror( "sendmsg" );
 315         kill_process( process, NULL, 1 );
 316     }
 317     return -1;
 318 }
 319
 320 static void master_socket_dump( struct object *obj, int verbose )
 321 {
 322     struct master_socket *sock = (struct master_socket *)obj;
 323     assert( obj->ops == &master_socket_ops );
 324     fprintf( stderr, "Master socket fd=%d\n", sock->obj.fd );
 325 }
 326
 327 /* handle a socket event */
 328 static void master_socket_poll_event( struct object *obj, int event )
 329 {
 330     struct master_socket *sock = (struct master_socket *)obj;
 331     assert( obj->ops == &master_socket_ops );
 332
 333     assert( sock == master_socket );  /* there is only one master socket */
 334
 335     if (event & (POLLERR | POLLHUP))
 336     {
 337         /* this is not supposed to happen */
 338         fprintf( stderr, "wineserver: Error on master socket\n" );
 339         release_object( obj );
 340     }
 341     else if (event & POLLIN)
 342     {
 343         struct sockaddr_un dummy;
 344         int len = sizeof(dummy);
 345         int client = accept( master_socket->obj.fd, (struct sockaddr *) &dummy, &len );
 346         if (client == -1) return;
 347         fcntl( client, F_SETFL, O_NONBLOCK );
 348         create_process( client );
 349     }
 350 }
 351
 352 /* remove the socket upon exit */
 353 static void socket_cleanup(void)
 354 {
 355     static int do_it_once;
 356     if (!do_it_once++) unlink( SOCKETNAME );
 357 }
 358
 359 static void master_socket_destroy( struct object *obj )
 360 {
 361     socket_cleanup();
 362 }
 363
 364 /* return the configuration directory ($WINEPREFIX or $HOME/.wine) */
 365 const char *get_config_dir(void)
 366 {
 367     static char *confdir;
 368     if (!confdir)
 369     {
 370         const char *prefix = getenv( "WINEPREFIX" );
 371         if (prefix)
 372         {
 373             int len = strlen(prefix);
 374             if (!(confdir = strdup( prefix ))) fatal_error( "out of memory\n" );
 375             if (len > 1 && confdir[len-1] == '/') confdir[len-1] = 0;
 376         }
 377         else
 378         {
 379             const char *home = getenv( "HOME" );
 380             if (!home)
 381             {
 382                 struct passwd *pwd = getpwuid( getuid() );
 383                 if (!pwd) fatal_error( "could not find your home directory\n" );
 384                 home = pwd->pw_dir;
 385             }
 386             if (!(confdir = malloc( strlen(home) + strlen(CONFDIR) + 1 )))
 387                 fatal_error( "out of memory\n" );
 388             strcpy( confdir, home );
 389             strcat( confdir, CONFDIR );
 390         }
 391     }
 392     return confdir;
 393 }
 394
 395 /* create the server directory and chdir to it */
 396 static void create_server_dir(void)
 397 {
 398     char hostname[64];
 399     char *serverdir;
 400     const char *confdir = get_config_dir();
 401     struct stat st;
 402
 403     if (gethostname( hostname, sizeof(hostname) ) == -1) fatal_perror( "gethostname" );
 404
 405     if (!(serverdir = malloc( strlen(SERVERDIR) + strlen(hostname) + 1 )))
 406         fatal_error( "out of memory\n" );
 407
 408     if (chdir( confdir ) == -1) fatal_perror( "chdir %s", confdir );
 409
 410     strcpy( serverdir, SERVERDIR );
 411     strcat( serverdir, hostname );
 412
 413     if (chdir( serverdir ) == -1)
 414     {
 415         if (errno != ENOENT) fatal_perror( "chdir %s", serverdir );
 416         if (mkdir( serverdir, 0700 ) == -1) fatal_perror( "mkdir %s", serverdir );
 417         if (chdir( serverdir ) == -1) fatal_perror( "chdir %s", serverdir );
 418     }
 419     if (stat( ".", &st ) == -1) fatal_perror( "stat %s", serverdir );
 420     if (!S_ISDIR(st.st_mode)) fatal_error( "%s is not a directory\n", serverdir );
 421     if (st.st_uid != getuid()) fatal_error( "%s is not owned by you\n", serverdir );
 422     if (st.st_mode & 077) fatal_error( "%s must not be accessible by other users\n", serverdir );
 423 }
 424
 425 /* open the master server socket and start waiting for new clients */
 426 void open_master_socket(void)
 427 {
 428     struct sockaddr_un addr;
 429     int fd, slen;
 430
 431     /* make sure no request is larger than the maximum size */
 432     assert( sizeof(union generic_request) == sizeof(struct request_max_size) );
 433
 434     create_server_dir();
 435     if ((fd = socket( AF_UNIX, SOCK_STREAM, 0 )) == -1) fatal_perror( "socket" );
 436     addr.sun_family = AF_UNIX;
 437     strcpy( addr.sun_path, SOCKETNAME );
 438     slen = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path) + 1;
 439 #ifdef HAVE_SOCKADDR_SUN_LEN
 440     addr.sun_len = slen;
 441 #endif
 442     if (bind( fd, (struct sockaddr *)&addr, slen ) == -1)
 443     {
 444         if ((errno == EEXIST) || (errno == EADDRINUSE))
 445             exit(0);  /* pretend we succeeded to start */
 446         else
 447             fatal_perror( "bind" );
 448     }
 449     atexit( socket_cleanup );
 450
 451     chmod( SOCKETNAME, 0600 );  /* make sure no other user can connect */
 452     if (listen( fd, 5 ) == -1) fatal_perror( "listen" );
 453
 454     if (!(master_socket = alloc_object( &master_socket_ops, fd )))
 455         fatal_error( "out of memory\n" );
 456     set_select_events( &master_socket->obj, POLLIN );
 457
 458     /* setup msghdr structure constant fields */
 459     msghdr.msg_name    = NULL;
 460     msghdr.msg_namelen = 0;
 461     msghdr.msg_iov     = &myiovec;
 462     msghdr.msg_iovlen  = 1;
 463
 464     /* go in the background */
 465     switch(fork())
 466     {
 467     case -1:
 468         fatal_perror( "fork" );
 469     case 0:
 470         setsid();
 471         break;
 472     default:
 473         _exit(0);  /* do not call atexit functions */
 474     }
 475 }
 476
 477 /* close the master socket and stop waiting for new clients */
 478 void close_master_socket(void)
 479 {
 480     /* if a new client is waiting, we keep on running */
 481     if (!check_select_events( master_socket->obj.fd, POLLIN ))
 482         release_object( master_socket );
 483 }
 484
 485 /* lock/unlock the master socket to stop accepting new clients */
 486 void lock_master_socket( int locked )
 487 {
 488     set_select_events( &master_socket->obj, locked ? 0 : POLLIN );
 489 }