2 * Server-side request handling
4 * Copyright (C) 1998 Alexandre Julliard
20 #include <sys/types.h>
21 #ifdef HAVE_SYS_SOCKET_H
22 # include <sys/socket.h>
33 #define WANT_REQUEST_HANDLERS
36 /* Some versions of glibc don't define this */
41 /* path names for server master Unix socket */
42 #define CONFDIR "/.wine" /* directory for Wine config relative to $HOME */
43 #define SERVERDIR "wineserver-" /* server socket directory (hostname appended) */
44 #define SOCKETNAME "socket" /* name of the socket file */
48 struct object obj; /* object header */
51 static void master_socket_dump( struct object *obj, int verbose );
52 static void master_socket_poll_event( struct object *obj, int event );
53 static void master_socket_destroy( struct object *obj );
55 static const struct object_ops master_socket_ops =
57 sizeof(struct master_socket), /* size */
58 master_socket_dump, /* dump */
59 no_add_queue, /* add_queue */
60 NULL, /* remove_queue */
63 NULL, /* get_poll_events */
64 master_socket_poll_event, /* poll_event */
65 no_get_fd, /* get_fd */
67 no_get_file_info, /* get_file_info */
68 master_socket_destroy /* destroy */
72 struct thread *current = NULL; /* thread handling the current request */
73 unsigned int global_error = 0; /* global error code for when no thread is current */
74 unsigned int server_start_ticks = 0; /* tick count offset from server startup */
76 static struct master_socket *master_socket; /* the master socket object */
78 /* socket communication static structures */
79 static struct iovec myiovec;
80 static struct msghdr msghdr;
81 #ifndef HAVE_MSGHDR_ACCRIGHTS
84 int len; /* sizeof structure */
85 int level; /* SOL_SOCKET */
86 int type; /* SCM_RIGHTS */
87 int fd; /* fd to pass */
89 static struct cmsg_fd cmsg = { sizeof(cmsg), SOL_SOCKET, SCM_RIGHTS, -1 };
90 #endif /* HAVE_MSGHDR_ACCRIGHTS */
92 /* complain about a protocol error and terminate the client connection */
93 void fatal_protocol_error( struct thread *thread, const char *err, ... )
97 va_start( args, err );
98 fprintf( stderr, "Protocol error:%p: ", thread );
99 vfprintf( stderr, err, args );
101 thread->exit_code = 1;
102 kill_thread( thread, 1 );
105 /* complain about a protocol error and terminate the client connection */
106 void fatal_protocol_perror( struct thread *thread, const char *err, ... )
110 va_start( args, err );
111 fprintf( stderr, "Protocol error:%p: ", thread );
112 vfprintf( stderr, err, args );
115 thread->exit_code = 1;
116 kill_thread( thread, 1 );
119 /* die on a fatal error */
120 void fatal_error( const char *err, ... )
124 va_start( args, err );
125 fprintf( stderr, "wineserver: " );
126 vfprintf( stderr, err, args );
131 /* die on a fatal error */
132 void fatal_perror( const char *err, ... )
136 va_start( args, err );
137 fprintf( stderr, "wineserver: " );
138 vfprintf( stderr, err, args );
144 /* call a request handler */
145 static inline void call_req_handler( struct thread *thread, union generic_request *request )
147 enum request req = request->header.req;
152 if (debug_level) trace_request( thread, request );
154 if (request->header.var_size)
156 if ((unsigned int)request->header.var_offset +
157 request->header.var_size > MAX_REQUEST_LENGTH)
159 fatal_protocol_error( current, "bad request offset/size %d/%d\n",
160 request->header.var_offset, request->header.var_size );
165 if (req < REQ_NB_REQUESTS)
167 req_handlers[req]( request );
168 if (current) send_reply( current, request );
172 fatal_protocol_error( current, "bad request %d\n", req );
175 /* read a request from a thread */
176 void read_request( struct thread *thread )
178 union generic_request req;
181 if ((ret = read( thread->obj.fd, &req, sizeof(req) )) == sizeof(req))
183 call_req_handler( thread, &req );
186 if (!ret) /* closed pipe */
187 kill_thread( thread, 0 );
189 fatal_protocol_error( thread, "partial read %d\n", ret );
190 else if (errno != EWOULDBLOCK && errno != EAGAIN)
191 fatal_protocol_perror( thread, "read" );
194 /* send a reply to a thread */
195 void send_reply( struct thread *thread, union generic_request *request )
199 if (debug_level) trace_reply( thread, request );
201 request->header.error = thread->error;
203 if ((ret = write( thread->reply_fd, request, sizeof(*request) )) != sizeof(*request))
206 fatal_protocol_error( thread, "partial write %d\n", ret );
207 else if (errno == EPIPE)
208 kill_thread( thread, 0 ); /* normal death */
210 fatal_protocol_perror( thread, "reply write" );
214 /* receive a file descriptor on the process socket */
215 int receive_fd( struct process *process )
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);
227 #endif /* HAVE_MSGHDR_ACCRIGHTS */
229 myiovec.iov_base = &data;
230 myiovec.iov_len = sizeof(data);
232 ret = recvmsg( process->obj.fd, &msghdr, 0 );
233 #ifndef HAVE_MSGHDR_ACCRIGHTS
237 if (ret == sizeof(data))
239 struct thread *thread;
241 if (data.tid) thread = get_thread_from_id( data.tid );
242 else thread = (struct thread *)grab_object( process->thread_list );
244 if (!thread || thread->process != process)
247 fprintf( stderr, "%08x: *fd* %d <- %d bad thread id\n",
248 (unsigned int)data.tid, data.fd, fd );
254 fprintf( stderr, "%08x: *fd* %d <- %d\n",
255 (unsigned int)thread, data.fd, fd );
256 thread_add_inflight_fd( thread, data.fd, fd );
258 if (thread) release_object( thread );
265 fprintf( stderr, "Protocol error: process %p: partial recvmsg %d for fd\n",
267 kill_process( process, NULL, 1 );
271 if (errno != EWOULDBLOCK && errno != EAGAIN)
273 fprintf( stderr, "Protocol error: process %p: ", process );
275 kill_process( process, NULL, 1 );
281 /* send an fd to a client */
282 int send_client_fd( struct process *process, int fd, handle_t handle )
287 fprintf( stderr, "%08x: *fd* %d -> %d\n", (unsigned int)current, handle, fd );
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);
296 #endif /* HAVE_MSGHDR_ACCRIGHTS */
298 myiovec.iov_base = (void *)&handle;
299 myiovec.iov_len = sizeof(handle);
301 ret = sendmsg( process->obj.fd, &msghdr, 0 );
303 if (ret == sizeof(handle)) return 0;
308 fprintf( stderr, "Protocol error: process %p: partial sendmsg %d\n", process, ret );
309 kill_process( process, NULL, 1 );
313 fprintf( stderr, "Protocol error: process %p: ", process );
315 kill_process( process, NULL, 1 );
320 /* get current tick count to return to client */
321 unsigned int get_tick_count(void)
324 gettimeofday( &t, NULL );
325 return (t.tv_sec * 1000) + (t.tv_usec / 1000) - server_start_ticks;
328 static void master_socket_dump( struct object *obj, int verbose )
330 struct master_socket *sock = (struct master_socket *)obj;
331 assert( obj->ops == &master_socket_ops );
332 fprintf( stderr, "Master socket fd=%d\n", sock->obj.fd );
335 /* handle a socket event */
336 static void master_socket_poll_event( struct object *obj, int event )
338 struct master_socket *sock = (struct master_socket *)obj;
339 assert( obj->ops == &master_socket_ops );
341 assert( sock == master_socket ); /* there is only one master socket */
343 if (event & (POLLERR | POLLHUP))
345 /* this is not supposed to happen */
346 fprintf( stderr, "wineserver: Error on master socket\n" );
347 release_object( obj );
349 else if (event & POLLIN)
351 struct sockaddr_un dummy;
352 int len = sizeof(dummy);
353 int client = accept( master_socket->obj.fd, (struct sockaddr *) &dummy, &len );
354 if (client == -1) return;
355 fcntl( client, F_SETFL, O_NONBLOCK );
356 create_process( client );
360 /* remove the socket upon exit */
361 static void socket_cleanup(void)
363 static int do_it_once;
364 if (!do_it_once++) unlink( SOCKETNAME );
367 static void master_socket_destroy( struct object *obj )
372 /* return the configuration directory ($WINEPREFIX or $HOME/.wine) */
373 const char *get_config_dir(void)
375 static char *confdir;
378 const char *prefix = getenv( "WINEPREFIX" );
381 int len = strlen(prefix);
382 if (!(confdir = strdup( prefix ))) fatal_error( "out of memory\n" );
383 if (len > 1 && confdir[len-1] == '/') confdir[len-1] = 0;
387 const char *home = getenv( "HOME" );
390 struct passwd *pwd = getpwuid( getuid() );
391 if (!pwd) fatal_error( "could not find your home directory\n" );
394 if (!(confdir = malloc( strlen(home) + strlen(CONFDIR) + 1 )))
395 fatal_error( "out of memory\n" );
396 strcpy( confdir, home );
397 strcat( confdir, CONFDIR );
403 /* create the server directory and chdir to it */
404 static void create_server_dir(void)
408 const char *confdir = get_config_dir();
411 if (gethostname( hostname, sizeof(hostname) ) == -1) fatal_perror( "gethostname" );
413 if (!(serverdir = malloc( strlen(SERVERDIR) + strlen(hostname) + 1 )))
414 fatal_error( "out of memory\n" );
416 if (chdir( confdir ) == -1) fatal_perror( "chdir %s", confdir );
418 strcpy( serverdir, SERVERDIR );
419 strcat( serverdir, hostname );
421 if (chdir( serverdir ) == -1)
423 if (errno != ENOENT) fatal_perror( "chdir %s", serverdir );
424 if (mkdir( serverdir, 0700 ) == -1) fatal_perror( "mkdir %s", serverdir );
425 if (chdir( serverdir ) == -1) fatal_perror( "chdir %s", serverdir );
427 if (stat( ".", &st ) == -1) fatal_perror( "stat %s", serverdir );
428 if (!S_ISDIR(st.st_mode)) fatal_error( "%s is not a directory\n", serverdir );
429 if (st.st_uid != getuid()) fatal_error( "%s is not owned by you\n", serverdir );
430 if (st.st_mode & 077) fatal_error( "%s must not be accessible by other users\n", serverdir );
433 /* open the master server socket and start waiting for new clients */
434 void open_master_socket(void)
436 struct sockaddr_un addr;
439 /* make sure no request is larger than the maximum size */
440 assert( sizeof(union generic_request) == sizeof(struct request_max_size) );
443 if ((fd = socket( AF_UNIX, SOCK_STREAM, 0 )) == -1) fatal_perror( "socket" );
444 addr.sun_family = AF_UNIX;
445 strcpy( addr.sun_path, SOCKETNAME );
446 slen = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path) + 1;
447 #ifdef HAVE_SOCKADDR_SUN_LEN
450 if (bind( fd, (struct sockaddr *)&addr, slen ) == -1)
452 if ((errno == EEXIST) || (errno == EADDRINUSE))
453 exit(0); /* pretend we succeeded to start */
455 fatal_perror( "bind" );
457 atexit( socket_cleanup );
459 chmod( SOCKETNAME, 0600 ); /* make sure no other user can connect */
460 if (listen( fd, 5 ) == -1) fatal_perror( "listen" );
462 if (!(master_socket = alloc_object( &master_socket_ops, fd )))
463 fatal_error( "out of memory\n" );
464 set_select_events( &master_socket->obj, POLLIN );
466 /* setup msghdr structure constant fields */
467 msghdr.msg_name = NULL;
468 msghdr.msg_namelen = 0;
469 msghdr.msg_iov = &myiovec;
470 msghdr.msg_iovlen = 1;
472 /* init startup ticks */
473 server_start_ticks = get_tick_count();
475 /* go in the background */
479 fatal_perror( "fork" );
484 _exit(0); /* do not call atexit functions */
488 /* close the master socket and stop waiting for new clients */
489 void close_master_socket(void)
491 /* if a new client is waiting, we keep on running */
492 if (!check_select_events( master_socket->obj.fd, POLLIN ))
493 release_object( master_socket );
496 /* lock/unlock the master socket to stop accepting new clients */
497 void lock_master_socket( int locked )
499 set_select_events( &master_socket->obj, locked ? 0 : POLLIN );